From 140fa111c47c91edf4a8217106ca11d39935b8f9 Mon Sep 17 00:00:00 2001 From: Sy Date: Sat, 23 May 2020 21:39:17 +0200 Subject: [PATCH] file generated for CN processing according to the values of Z | version for AVX2 and AVX512 --- cmake_targets/CMakeLists.txt | 22 +- .../CODING/nrLDPC_decoder/doc/nrLDPC/logo.png | Bin 3723 -> 0 bytes .../nrLDPC_decoder/doc/nrLDPC/nrLDPC.pdf | Bin 281923 -> 0 bytes .../nrLDPC_decoder/doc/nrLDPC/nrLDPC.tex | 960 ------- .../nrLDPC_decoder/doc/nrLDPC/references.bib | 105 - .../CODING/nrLDPC_decoder/doc/nrLDPC_doxyCfg | 2427 ----------------- .../PHY/CODING/nrLDPC_decoder/nrLDPC_bnProc.h | 4 +- .../PHY/CODING/nrLDPC_decoder/nrLDPC_cnProc.h | 6 +- .../CODING/nrLDPC_decoder/nrLDPC_decoder.c | 1190 +++++++- .../CODING/nrLDPC_decoder/nrLDPC_init_mem.h | 22 +- .../PHY/CODING/nrLDPC_decoder/nrLDPC_mPass.h | 11 +- .../nrLDPC_tools/generator_avx2/Makefile | 12 +- .../generator_avx2/cnProc_gen_avx2 | Bin 0 -> 188432 bytes .../generator_avx2/cnProc_gen_avx2.c | 26 +- .../generator_avx2/cnProc_gen_avx2.h | 6 - .../nrLDPC_tools/generator_avx2/main.c | 16 +- .../nrLDPC_tools/generator_avx512/Makefile | 12 +- .../generator_avx512/cnProc_gen_avx512 | Bin 0 -> 192544 bytes .../generator_avx512/cnProc_gen_avx512.c | 22 +- .../generator_avx512/cnProc_gen_avx512.h | 6 - .../nrLDPC_tools/generator_avx512/main.c | 24 +- .../avx2/nrLDPC_cnProc_BG1_Z104_13_AVX2.c | 2334 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z10_13_AVX2.c | 2334 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z112_13_AVX2.c | 2334 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z11_13_AVX2.c | 2334 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z120_13_AVX2.c | 2334 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z128_13_AVX2.c | 2334 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z12_13_AVX2.c | 2334 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z13_13_AVX2.c | 2334 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z144_13_AVX2.c | 2334 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z14_13_AVX2.c | 2334 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z15_13_AVX2.c | 2334 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z160_13_AVX2.c | 2334 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z16_13_AVX2.c | 2334 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z176_13_AVX2.c | 2334 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z18_13_AVX2.c | 2334 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z192_13_AVX2.c | 2334 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z208_13_AVX2.c | 2334 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z20_13_AVX2.c | 2334 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z224_13_AVX2.c | 2334 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z22_13_AVX2.c | 2334 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z240_13_AVX2.c | 2334 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z24_13_AVX2.c | 2334 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z256_13_AVX2.c | 2334 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z26_13_AVX2.c | 2334 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z288_13_AVX2.c | 2334 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z28_13_AVX2.c | 2334 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z2_13_AVX2.c | 2334 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z30_13_AVX2.c | 2334 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z320_13_AVX2.c | 2334 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z32_13_AVX2.c | 2334 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z352_13_AVX2.c | 2334 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z36_13_AVX2.c | 2334 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z384_13_AVX2.c | 2335 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z3_13_AVX2.c | 2334 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z40_13_AVX2.c | 2334 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z44_13_AVX2.c | 2334 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z48_13_AVX2.c | 2334 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z4_13_AVX2.c | 2334 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z52_13_AVX2.c | 2334 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z56_13_AVX2.c | 2334 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z5_13_AVX2.c | 2334 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z60_13_AVX2.c | 2334 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z64_13_AVX2.c | 2334 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z6_13_AVX2.c | 2334 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z72_13_AVX2.c | 2334 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z7_13_AVX2.c | 2334 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z80_13_AVX2.c | 2334 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z88_13_AVX2.c | 2334 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z8_13_AVX2.c | 2334 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z96_13_AVX2.c | 2334 ++++++++++++++++ .../avx2/nrLDPC_cnProc_BG1_Z9_13_AVX2.c | 2334 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z104_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z10_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z112_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z11_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z120_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z128_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z12_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z13_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z144_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z14_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z15_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z160_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z16_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z176_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z18_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z192_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z208_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z20_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z224_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z22_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z240_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z24_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z256_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z26_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z288_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z28_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z2_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z30_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z320_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z32_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z352_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z36_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z384_13.h | 5 - .../nrLDPC_cnProc_BG1_Z384_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z3_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z40_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z44_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z48_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z4_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z52_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z56_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z5_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z60_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z64_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z6_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z72_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z7_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z80_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z88_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z8_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z96_13_AVX512.c | 2340 ++++++++++++++++ .../nrLDPC_cnProc_BG1_Z9_13_AVX512.c | 2340 ++++++++++++++++ .../PHY/CODING/nrLDPC_decoder/nrLDPC_types.h | 1 - .../nrLDPC_decoder/nrLDPCdecoder_defs.h | 15 +- 126 files changed, 239641 insertions(+), 3626 deletions(-) delete mode 100644 openair1/PHY/CODING/nrLDPC_decoder/doc/nrLDPC/logo.png delete mode 100644 openair1/PHY/CODING/nrLDPC_decoder/doc/nrLDPC/nrLDPC.pdf delete mode 100644 openair1/PHY/CODING/nrLDPC_decoder/doc/nrLDPC/nrLDPC.tex delete mode 100644 openair1/PHY/CODING/nrLDPC_decoder/doc/nrLDPC/references.bib delete mode 100644 openair1/PHY/CODING/nrLDPC_decoder/doc/nrLDPC_doxyCfg create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx2/cnProc_gen_avx2 delete mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx2/cnProc_gen_avx2.h create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx512/cnProc_gen_avx512 delete mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx512/cnProc_gen_avx512.h create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z104_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z10_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z112_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z11_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z120_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z128_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z12_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z13_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z144_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z14_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z15_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z160_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z16_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z176_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z18_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z192_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z208_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z20_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z224_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z22_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z240_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z24_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z256_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z26_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z288_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z28_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z2_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z30_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z320_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z32_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z352_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z36_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z384_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z3_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z40_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z44_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z48_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z4_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z52_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z56_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z5_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z60_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z64_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z6_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z72_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z7_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z80_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z88_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z8_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z96_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z9_13_AVX2.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z104_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z10_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z112_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z11_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z120_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z128_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z12_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z13_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z144_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z14_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z15_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z160_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z16_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z176_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z18_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z192_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z208_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z20_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z224_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z22_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z240_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z24_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z256_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z26_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z288_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z28_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z2_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z30_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z320_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z32_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z352_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z36_13_AVX512.c delete mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z384_13.h create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z384_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z3_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z40_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z44_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z48_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z4_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z52_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z56_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z5_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z60_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z64_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z6_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z72_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z7_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z80_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z88_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z8_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z96_13_AVX512.c create mode 100644 openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z9_13_AVX512.c diff --git a/cmake_targets/CMakeLists.txt b/cmake_targets/CMakeLists.txt index 654af83d97..cf3a290776 100644 --- a/cmake_targets/CMakeLists.txt +++ b/cmake_targets/CMakeLists.txt @@ -167,7 +167,7 @@ endif() # set(CMAKE_C_FLAGS - "${CMAKE_C_FLAGS} ${C_FLAGS_PROCESSOR} -std=gnu99 -Wall -Wstrict-prototypes -fno-strict-aliasing -rdynamic -funroll-loops -Wno-packed-bitfield-compat -fPIC -mavx512f -mavx512cd -mavx512bw -mavx512dq -mavx512vl -mavx512ifma -mavx512vbmi") + "${CMAKE_C_FLAGS} ${C_FLAGS_PROCESSOR} -std=gnu99 -Wall -fopenmp -fopenmp-simd -Wstrict-prototypes -fno-strict-aliasing -rdynamic -funroll-loops -Wno-packed-bitfield-compat -fPIC") # add autotools definitions that were maybe used! set(MKVER "'MAKE_VERSION(a,b,c)=((a)*256+(b)*16+c)'") set(CMAKE_C_FLAGS @@ -1305,31 +1305,27 @@ set(PHY_TURBOIF set(PHY_LDPC_ORIG_SRC ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_decoder/nrLDPC_decoder.c ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_encoder/ldpc_encoder.c - ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z384_13_AVX2.c - ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z384_13_AVX512.c +# ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z384_13_AVX2.c +# ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z384_13_AVX512.c ) - set(PHY_LDPC_OPTIM_SRC ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_decoder/nrLDPC_decoder.c ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_encoder/ldpc_encoder_optim.c - ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z384_13_AVX2.c - ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z384_13_AVX512.c - +# ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z384_13_AVX2.c +#${OPENAIR1_DIR}/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z384_13_AVX512.c ) set(PHY_LDPC_OPTIM8SEG_SRC ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_decoder/nrLDPC_decoder.c ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_encoder/ldpc_encoder_optim8seg.c - ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z384_13_AVX2.c - ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z384_13_AVX2.c - +# ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z384_13_AVX2.c +#${OPENAIR1_DIR}/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z384_13_AVX512.c ) set(PHY_LDPC_OPTIM8SEGMULTI_SRC ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_decoder/nrLDPC_decoder.c ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_encoder/ldpc_encoder_optim8segmulti.c - ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z384_13_AVX2.c - ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z384_13_AVX512.c - +# ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z384_13_AVX2.c +# ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z384_13_AVX512. ) set(PHY_NR_CODINGIF ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_load.c; diff --git a/openair1/PHY/CODING/nrLDPC_decoder/doc/nrLDPC/logo.png b/openair1/PHY/CODING/nrLDPC_decoder/doc/nrLDPC/logo.png deleted file mode 100644 index 7b785ca0517c0aa7467aafebff9255b2bdf0b8ef..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3723 zcmb7HcQ_l~*QZpKvIIZ9D8A_L(Nlzj5k-+7Ue-=fU2;YB$FPfLyhA9*Ce5QssEb)of9eM|CmU` z|Ib7s{$Hj@amv_Cn}-Z1?>u9Z&3Uy{x%qgnT_cOW-&OYITa%ca>)Eesd8Ja|>3LOk znraDi#RBjn6#q9#8;kU&2nD$CVj3Fhap5@+7qI10x@~NEDBmf{>+IYcgrK;ZZPc#x z2^)%nQr`MOuTCHCxTF?2168#BXL?kcd5FxDkJi{Iy5`1C#-ykBpQ#3rf-5C5-A7`o zlx?2T9*F*vh0#~Ov*znN(>1g$tF6=&`E#6w`t7cOBVrHrvUsG`bpRrfnsO4FkjLY= z!#ZHyE*H!o@{Q9_?Vt_a%c($B@QU8gjyuT~H_rvcx(*qAW->Lr>$(Ss8dgX;uRy?| zW}5+w3$qzb^-`$E3Sd%#-`zU>ZKndZeb#`QY$wGvzvRnfE%SShUxyMv7fWc3xr;oy zEuqK341;|catTpIA8PuDWBINa{5=PtGrsg!y|FqQ!v4X*pqPN$L8C->I7iD$T&#W~ zu|9J6g_1VD-b|uN{wIt_fV0G}duJN1<-n!!!ct=`FNY#9KXOu8OP&`}MCHv`JZ_;r zN9G)nSYE~BwvZynC<)5q|~BvPD?y522~$3UjQ!vHk;MBW{y^&l&R&g{y7WE zB%$J6mPR1@c(rZvSu>1FBKPYYqBBD}VQL4#2PtNafBX*&rNnR~M8t(L<#?E`I4A8S zrhCYn>fP}dyWo6zjicnrM_P^uK4Pft*`kHHQ9yLT(a6VlD^{S3)!KOT>k$UuZz*#h zq_MCZ_dC2h6^$ZZvGGbiehDleEidD%nK1ZxJeB3gYi9fFp-E(XCbFZ+; zwTdXV0W2PDJ;gjF8*f2i?wsOKkNJV*0CRUGGr^&^`#5Epy=Rkmt3(2L?PQV{+-UU# z^Ja_@uOF(x?mVyCE*ca=%+%30Gb1frGlf57q&uEA<5=pP&0YP5+I@XSLgS3R1%#s zWbT%-z_jU&z(lN*9#wZq`1ZuzE)E4SZdxB-FXMT+0fq#*-#efk9<&ro(xyi*KTo6+ z-Oh!Vmda2&iNYVIDmMKy+CWENInI=G=`|0J9rmqvX`Js})Y$|&FVb|-5gfEZrJu5L zi5}e4)JoI3JK5+Wr?F4+lU~DPj0YXkNz^aG0UeQc3=Itl@0>|*AfY)f-69<0Esg|< zHECu5GN4tZU{kM6QDNzQ+H0U zaZNWXDyeAs)E4d*m!;yk9>w{wXBp_^O;JgFBeihGxt{5+ju}yqZOj1VfFBe0%sfT$ zGT}b@=!KljI|0rFiuvzJ`;HD9b+TJ5sS|+&G_YtQKvzgqlKs)BFOFh{F26}^xbU8G zmU~pE5qxhaIRM<#AHX^njPhk&m5=gTzP$&MA$K}1-IZ}cl)yXNDOjQZJ?j~bI}~rIk2eP8#VWGJKZ+zF$fIxKCHY{Dr2tTKrYo-^GuY9rv~F-)FPC0 zY1LFL7or%LjY%|L4TgEyQ8(g-uAZ6z`ZAP?Uf3sVQ9h;G_y7C78W$*@z}^y@g4565 z<(+Pk*@=j^Ou6Gz@-FN*Jnpwe+1mkE!rdN^s;=XPa1V}gkr#Hjb&msC*YUq*3{LqH z>Mk7TIG6s{uW^Gxq5eZZb4wGrDn+Y6-iLg;Pi`L+ECzr|6pHk=XIOyc&v;G!6*88p z247ov_j*PRE7L|NrAdo+^(h9j4gcOnGy%M^0?t!IZ&A>Pl;^k#!TEZHlA;e)?Lb^1 z;~}>xvIdSBeoR5=-`y0W%4(z+Ah-ctn{fPomnRA4Y5;a(`$^#of5k=$Nq0&++Q4wB zgMB5XHSuo*#|Nl#dxxdXtjzBf{*7GSe$*=+Dv4L;fD6U|8J{saFVoTI2KZ(>%&^=o z#=$G7Joe{(lP7AX$4Mwzd2B>sBs<%{{0X!b_Pb*CFZ+&OsSr=1VA8fin->3$R#pB`%3vH z)p_Hc`Ph4jXUfS0UBI_wCS$)HWl7j36(mTSZgU!(uFlX~EAeIG@&KgE8!qJ{StNTI z&)~&n^mfz0BZ-E3oBhx8^PLW5N!zDd@l=6~Of~oij{JYlORh5otcmaI%YQ~VpbhWc z&k3R^Izj|{hTClF7o6&Uvl)O?_eBrv-8atLif6E*6X&^H%rXZ|sF2FtXH(?I^|EFY zr87BFJvgeh9O+SN3t9}$u&7OK@Rfxd7I&AJRL4)cA1M3ewVPc9m)6(kH_FV{e@Gqt z!mlehRxg5*5i;ufQj+&^{cs0wf;e#kkIzB|i+;sh)S8X}lg;0Q#p1s77>r8p_+Mvf z?kW~IeeQYpbCI~VFiM6RmA?~|Tkv<6_NLOj34Iom^E@WkLtNnG=MjX+H?;76@dgeLS7#XzrZvML#JVpV)IEbiZd?Zc(?wrBOfEYXMkG(hDeqHS~ z*MpdSSy$njlsRFFf82RG?GDeTm>qI?94|x(pIk!WdxnoOw zq9%gdvu*;sl003d&+uIVgdENtdj_&x1l#O93a$L7pWchswsiqV<^hVf`{t}CR@KGY@+1LPfH9hnm&Ei{@R6wvXf();$ZnRe)t91LKba;KUoe)Yx3hZ>8H zL2JE*#j3OkBlt48(~8eRv`nNRme|g+GCVrd3vmwAiF{WS($j+rJ2}aUmdNzwQO`|$ z8oeg!=I9_DvOz;bs&_C~S_#}tSznqbSd`~bW5{AV=b{fmR`&z_p64)GfQO2HWCk9? zspRlmYlmy*Oi)9V2XAU=`@~^A@&`_ts@mZcMA}bYjc&V4;1EY|`kRpok-LFQilp31 zn&qP=DG%6cTu;85g{;tB-GE#V`@_gkT=?fCq4kj!-NQXpQ6Au>BR7wGyfAj}O)-bm z9P65F?z_hawZo*I{8&R6W?drFg8#ammgnE-`a8kof&WHrQ5qX0(z(!Gt-RnkDl=v$ z*Y|FzCH|Zo{ds0j^_Y3&pt9_+T;~egq7^MsH=Grx5O7G2E~CY$9#i!>HkJ)+#?05d zkv~217W)VryS#DPVx+=zRc$i2m$3c|o8&mc@1bNSjN->^+OkKsip+l!d@ctg^b&rN zRmv_7>=ST*yT!^*kmu42KGr$VRmJ5T_f?KNAGltZ9SQ5rC@a)gWwNE?qIJ$>W-<+p3T0|%a+;D0^p6#on%*5 zt+jFvse*_YEh8N(6zSa3@EQ~c0Rw@(krfmV4-~zOshzot1py;76C1&QHYj>AOB)wc zCjxpg8$%aU5mRG(6H_QYJ}74wCsRXPD36Ul>YH|(VhFyg>Q}^|A(!3G>*YdnMkK16 zLyFo3l6V+VN)UHN2`b4g{JZPelH-lW;0!*5oLjlP&Soc9Nd>$_XI6qe&bqc}=(Cj~ zEd4Q3fo$AE9Q`qtB`l+mI_%m{Y#-NNn9c)5&x`8mH#e4vZIc<57TPY8ui5E)VuVtT zRHV&z4p3nkmNm*JIbD=|Cf^EXupR-C{^WQrNXc^TG7j6%xHw)Zy81qj%JD5X%+(+M)5X*8mq-EScTPt+!d`Uq3X z8hgx4C#x^LpRkX{4t=cRC=~@!nBXXb)W7V#v(_#bUyDG}mm~U92hd`n&ahoxhr`iX zMdjBAf8GV1&&-ZJTA!?s{INfOc~YI{$Syq4T4kHXDCJO<*|?MXxzI!Y-&ACOn@`JU9ThxvV-1*M3~&7?!anSww|`t-a{O3foIOT^-kM{bra4_j}mQ zf3t8k0?q@M~Y=M-)44y0OPuY`@97E0(f}SmB@hXnp+-hdQj3sj@#YkZP$fF^r z0lS2Z?Z*I+g$5Zzjx)%-$CMdKe?^cv{9^v3{mQ%NS_BdxQH~P8QJ%Oh1u4INw|oK# z1?+*re?GYO4r(>U}Golvxl0VhFHmoorWEn>c~by zfQ=^mOt%#UFU5B4kxoP5gWI44db8W1zd#|GBT$vx{*&S;hcaL^hMEAkB ziGH)6@XYHn&zX~4P=FCz#mT`}_IuL@gqtuIVER2;<}U3zTsZMybUEk4F!%McwW_fB zLIOgsrtWylc1c7}Xq5(IMcRi?5U5Ucz;PV*PzssfYV&$2qu^UgX~;!bjg5BiJcgp0t6R z?UTV3G&>&zvteB1s-%kBX`|{#h?%dtu)_T24 zRxPcst-I15mLa57oBy8ZtC`IrWF{N&ZEW_~aTdRP7eF!rj&%4c8Bw+EDP;Ejmp9IJ zJNCs=c>nfPA*wE13`Dy~k!EHWhOTm-TF-BSYbq>FwfyXt2=-VI!PM()Ua&c<~xT@1ZQ|;bY}`qmJ#4Ji#rQJy^b) z&SWet-1{vfvnzyl+%oZ5>up}VZ2~QhcN4px2udIBr85NyEPU*~fC(SOJn|P19M44y z%GA!}e*x#er~d$5mj432DxMCe1oRs6MpmZAE>QH!u0}5Z8IiO#G&hB!SGP3z2hB{3 zEKu|krk3UwE(DBB98mN^mM+c;rcT24whs1orgkm_|6;=SHug@+4u;16@`;$bSsI%v zi3|P9C~N3!O~A5y`aJG#3?vToCqZR{K#LW1K&vd=(@ z&_WOtEDWtCN(qr$Xr*1JKZn2o^r_dW z*`)q5Rd)MH#^pA4e`V&roAAx|_)gBuecN;U==b1VxBEzwt|uc-vY1E-Fb0&ZC811} zr36d>&4AD+0068A4*&*)0RaF5!hisP0bxJ@@Skx5f`CAP|Ck5-*MkB5>tR6t-!E*~ zC0x>5;4RQHFxW!?QMRfCp+zMZ2(Mgk5!6{hptBE=cu`Q}Rd|a@i&|EK+D}G60{aNR zGvQ)Nl^k1;&oR^LsxsA&y<9+zAKzNBy!X)Z>^>Z#yez8?BhNo%0$)_Dbn$?yVq60Y zD`%MCQA^!5r!Yu<=w=kG$P^)COQxn^>tDnFP<(x;Bj7gQ$pqUfGHkBtUH&^ z4X?};8JM6kKyorDP?*&jL6|J7ZOsa9jfZ=J4B=i^AGC^+ywR5)W(H<@LN3?-d2*wk zZF?{Fs8PFY)%^%JXSmNCc<#QiWtzvj)OSPRJsAz3u3p`xCuC0mqk1ozzsZiZ^{sIL zHRXMI3W3YBdm@=Uxz0N=>)j0)CGx7keifD!8qhOBLeAdrsU?N|OD+%T3x+XrOv~;1 z{G7J0&(FSKq2=oJTG_K{EB*e@u@)5|SXf!07FDa|g-oXX)Zx6U3@W;&fx#GN##qIp zPI~>DL!(+;8~*oDhjE+fcXk=-r3`h|biF;wPYeEcOX_h~ch=#OB^Om`^eQ0mXYIdK z6J2h?*^|e)-YmviOzvuTP8h?N7w+COT-bcNse z;%5-9=Jp_9A01>5s=~WWbH_hDfkI16Js;flKn0f5_!${42U5z7h*{-irD^&q%3C)bNcJqN=VxPmGL5D0P@X=OMPaC+vRzk!iq=e z>3TQrv(-!T87oz#lKR%ykd)Q^mp=Tor7S&7DRUYIl;9*h7i+%Hg9Ftq&!JCE=TSL<&PRxf+^$~02E;3dLBPJ{W~ zr@)Ya&lcx^H{yDXm98a{Hilktt;o=TkEOwt$P$0sds@oLg$ffA=!X+|MlM6jdY7MX zU1{Oj7BTSeZ4E#x1LNf7`vfq~{DDX131b7x<=hh)0Duh(ZodU|CI3yM(=i@E%LWB9 z%+(w3H{z8iThQq2_Myk7#q9Z_(zD5Ogpb9h zPhUZ{8tCw_Kq=qh7PT5ihj_tM0%+utuwu`3{;k@<7FN3{#t#f|SdFvDgh6J!E@fJ+| zs)x1fBczVYOIOp>5NVPFOr28X?btR6Sbq1wX^gE;9LxCis}7HK*Ty<^osNYj^L!5% za{^dMN8nI*+Ahb_Q2MS-9lO?ywA!-aU>{W7r97#qJRdjKj$tkB4vCLF%e^@QKWJ88WUv#QpSKv5}K|;%XUcYRRt*+(p%C zC*g6|Mf=I)eZPHu0oWA0Jp+o~3$L$74jsLAF3Y;E%ev0~&YjcOFULf9@yD@kw+e`U zn#h5Huc?6tHjwHn2R*LZBfe8JkLV!+8_%5qf#2(WFSVDli)N7MDWbh%`(r|Cy?hsqo4@^{=wZ6_ zVN<}!J|@m@!mtHBdT%b-pOEoLtNk%BxWJ;SF>J&dZGZa#^2~4CHu*Vcj^TuOz8N?^g8MZK@+X{ln<@MAVK2Dc$j*yo#mRngqCa$g`K&m&0C^ zjs?kS`k$4KYur(D@@;+gR!&`$Z;<5bo2KjA@Tp~gmMNbw$%#}qp7)kVUY<<+mx8w? z-qo0VirS;-Q3*)P!jwz`*TEKE^Jaf>2RHc2l6>dbQex%yEyNCRa%{7&63_nVvSDgk z?42gN-Q^~0`^g<&T5rCF8=u*Z7|3NTdKnTu6$_4}o z4v(m^l>mSPW5AfIcrYN2Vgj>>Fd$4=60kXdz<@AemtwOZfCFuYEL@85g8~Iw4JC}= zk~3icg$5I*gzP*pVL+IsMXTQvk8N#j84$*nL7LA&QAGO%2xgreoO*ulHU9;Hkc$nO z!IhN)0|mfsD<70SE4GMav*Q$}vZ6EFXl&mqI}OTk1g1lPNi2 zx)}YI^x#&XrT+#i`fr;vP{{+Gd@lla6Pntw_Roz4x5}sEWXgkoN$5pNnIhM9_AAOV zow+x*nxrPm2afsrM$8+cWB|BACC5q*nJ`4zl2b;j9y5-B>_j}hg9OEgvYDbUMBni( zgRJZRJ8Az<2K|3oCjWo3c5x>|&;OgKGc$1fpFEx5|Jjtep6#bP0>lBo+bt*+nV84s zkf&R)f`5e2_D;ab@raR}naGXi=?jZ?b!dWb;G~RAS(3`yxcV{AX>0%Imv{!xJ~u=% zf6ZfqaWyynf7-lW<%rb16RYixtZ1E<<8-D;>ipu!>sm*U)TL3|KUmY-FXTY#@Y1Lq zTsi)YzyAQK?}`JdyXRBeFJGzbT^P|gxH9W|R{NDds7<#`Xn*VCPiynqstwnARj0Ob z>DRO`U%%M=Sx^JlzwigFKAdq0t#vRZPvoP`lVHwd={ z?^oC+uu$Td3;cdlNIO0**I_mQ*~+(ALoMY72dHV7C`sC(cGXjmTX64NY6k6h82!)j8hcLNoM#YSOJSguhhQH)QIcyEpMePJ*%D z-~9DIc$q&|vGa6?NG3kbN!e@(l*k5QUvUiKb{JjlCq94Q{+`+;B}=2tcT(shQT@cx z+HK5KJ;PY)eO3ialS6hFGNRoRf#8bYk~vMAN^$HCB#tL4bTaSFyUjqQkg zA#^)v^*wOHs#Ka8y*E@?X>K|8Zq|@S={Y;})R&i;R+}94 z%tV!ndhVLqG>d0;aHKu57S}%ICr?KIOJeI23Hrifp*k+ zWIeIX7vY0Gbi?Z2s-TsqL!qk?@C?)a*OP(k9k^s0{Q7@${{O2t@xRVLGY2!n|I{p4 z)|Pa~VTbGaRDWuG&Kq{nC$m2>Fh4Ls`s9q0bM&EbO!Uu?=w?p%}KY*0)ovq9Bd9G!HF3em|qpRDY?=nz(4^0lkBu7)f9NsK# zZ$}ZzI)43xCQY;TZEp|RecrCBh5L+lSO0y#(C&qx(Xe!c=xI+0^33%5^=MD<^Mv;e z((+Tj$*vj>i(ey1ufP9WA#Q8+?xS3H_uMP;K+XO&YOlv1t}jSStpVtxpAPG~h9dC; z_?sf)hzmL4Bwv4t#Mfc^mv?Ib+(Sco^m1NG4`tKVQF-M_?K)Bjq`Km`)?<{8t`=po zS~gQnYY82w37a%~tnYFyFyhpWh$zmCY(CjaW5_hoRJf z)e&_UF?0`lG65ZvbWG@dpAge|=k4W#I^7fAQlJ`zScnwUsH^xp6El*G>1U-{ zxbNZ$C)NYAJ+qHx17;Wc+Jy&ep5?s#_CD`) ze#%`2CvC>#Pt2E~43-y3&`BH|P+Zmd5)M5h1X)d1(~GWI=|Iq*3(a?PGm`#HL|)L@ znq3C=s{?)}XOGzsh+rfvI<8WE9V^5PkZYtk(79I$AumufcDuc8xcE(0O?n=yg(QW* zf{kFA&$&2Lg&KOHTT( z+1#l37G)0bIeCx3a|g*ctd)DJ8KjvlxZj5jX!HG=S0oVTyzNpnj(EGBbUP!{V}m)X}v`wq`c zPS{{*PK2>fyn{MuRyaeU^DtvuMF;Eo+6blx*RKQ5O#ra3pDdE|zdkRx!LCAp3ezz8jh>Dfi>0I(x*r&0UOwESlu1#M4IJY*W2FJJ z*^TJTS87aGWTvuk-kq8WzGLT_+MJ@8Z<11jC6PKrBEX}rVGQZte4ojn=|I~b6VyJy z;)AqzSP=y%d%wQxEUG4#N0(c*=Gk=?<#9biURR$BdAF8^ufuj0yY4`6hnku#rj>1A zCZke4uTF)^UR$MU|+I$_y!){SIVIzsMY?{}OD;ds04~vdkV+$bY zs?91JE*nXJ7=@W;blDjd?K_l-8Jj=cL1XCxXk3@?MCSP{(1bK%CXi%azcAh z25ZQOp<<40AHorv2(Iv1`rVN)4e(`!%pu)4+qf{)vgW&FB9GI+67_g(u4S7YHTHl) zZ5WBXZkJm&r&k`QEz?&}1S+)g#+2-v33%8V{K$P87wK>-HHOZ8u$Z|>U=PxfHLGr( zY9=4j5mRJ|}LMVC+@_?;fbD~9kfR}IBT&jzkY zqBdX6fL|W@DgCeoVBX4BFXa!pJGE?+6?bv{ zm2)^oAUk1V-m~MyD=<%udS=Y){SRfis+=3O5j6le)M9bA4r z{0v}zLSuemI3th|V35enD0i}H^0rr~MPAL90#W#SB4DZAGo^+_@Q0cvThC z$jgGqM0eX}OfiQZMIsbX*PlV({5k>3jVKx?8$eIsinu5|TI@7-CY_5v-^zt1;YR6# zS>FpLn3BV=7r$vI%aOTp=kQ~6@#qMMgOf*aetf+SZdsLQ;>2$Ao!b}a%L5j1?$8?j zb=hqbG*P$p-tgB_FpO}DiWfOh0LQHSiJOjzS>4I*ZG^h z-lq=Tj|YiZH$Va%XAb7Bq^bg+5PxnRY_XBtZ6X+(B|Zf21LrBht82_P^Wo2@t1xxZ zMfK%W62EHubEU&&r5twtSjpeIk|@z053VHypuSbxKh+ych1nr=c3<IJ54gMv`@^M6 zYC7Mx+SgIE-3pB$8k4F|K<%prJv`E?2NtR}^V+T32jDU?XsUs{C{7)#xC(i7C`Jz% zF{ogE$L2<^9mH$@N_=49&SSJToO&W??kJU!=iFsC_<>KQ(1)SFOc9vTwh7?40;&ZgRs zBg=WTn`MmzB(Kdt&&0OxA}By)qg74J=I-rT!$yDuL62sTp69I!ge{?-zjQ?|Z$s z&}D9su~+)^$yOoUjpvqJ#iDeD7~&tu&9ozbp}7Ct?!)=^GEJ(3tN0z!>kc1~ar*7K zP}B)jm*f|E0nsCximWSuGmgcy2oETozCnQ_=@yCxu&<9Gqe(yEV_S80Z`N;gcIXf< zAZ-5uxIzo&y^3RfW&2pk`hd{_&#SyuM|$srQZQqc9PEKD_+bvA?V6}SV$v!fuBkRt zU2-Xf)r_P919340)Y{28s0YH8@ zav++1RZDM4Q?|v&ziu9z0}NrXV5N0LrkBl~hsP)6fW~Z4Z2Lxt4-T)Ygo7KGvy20m zKX3Q$oQjX%yw?v;2Evo2`xEVD{vz4WcfJF`H|?d$tdsIh=>Lph{Q$p(1FV8La~Ta~ zG*UZP!LTxnoMFeh&PUfDEpV^0w_LpG;_N3+K3JAf+G!pFt6UpQKb}&^QqNW7GY6L; z#BBS_a`zh}MT?Vf>B*l(Ce8rlZ)|{{U-Ha{E>C?D2DF19GaH1@xpfYFbZ#lZgmov- z@jq4u`rrVhB>2oMH?kdY1;dIpL5A+Mi9&H(5Q(U}^>?|3O zB#X(`CCjBIS0@gr5m9>$c{r_;m)}zaQ=ZWHID_&PY@&m&0?eDe$nzb#>RW&QrFTrc zq3xUr<$}Iu&#ri!^N?MADo7ABp7bo?#Zf* z5A}0_o$pgCgr|&VonM5KeUgObDsH*Ou(X#H^ALnlXGv64QWeeHr#$X}`?UQChb1j0 zSIpH`;jB*|AFupzQ}G7}anMkG9r9#N-eKS-7#7z-jBA*>prH#sTjoQHL@rk0jo@D& zs>07)LB`&;e!Y4@5?e$#15g+;>ApGUCk*1a_ZQ$w^!V>8nwj;#yGYC|oJ{{y6@9Fu z>5S8c=(k#*(MD6v!f-Q4$1mb^MRMF;lOfNEr*;&vHG%hZqZIYyi)EqX?2tZrEG(ib znUg7YDC~YH49wgNys^d7@_vpQJIbD3-}A0m6~=gwaxi@yKEhNKY73(-g1Mrj$Nrnc zI6$v8(w_DGHCS&?uVuJ&6@Fs{Y;NP$t+A`~_4!c0`(=SGo^!G>I9Fzx262h7|IpfL zQQFjesSvAO14hKY>C;!FGUwY7Flgo-Tal#R5aWD60saQy&1$!XSgS*qUyu0d8*tOm z|DI~U=Qi*AGMou_jp{f@C#u+OHWgeBN*P%go>;8G|b9?<5q|vci{J_h0D;?CY z=jLg6Y}2FXuHDtMK67iQI12u^{PS|N7ZF95Y~Jng@ZM5=m7y~1g;jxR*R7v>!yOvv z56lP?=OBc;14Hv~fkkeId-&>aQB==2=nqpDn17v*w2WXf`qXIPG@tQ$Yv-n0r`@&U zD}_+=-jN+#f-8!;n_L2rt2U;%-C0UXU&0 zp|~wiBnie(>7jwOen=Q1MDY2LSxX7aMRL*kZDrBS$2bu0^d^ zPXJIqmoCWS;DWtVyWeo!iya%IV^24jx)(((?N#Q68)Fmbh|b>`b@xdNAeXBUdwahi z7W$9~UJ`=zE4SBbxMUh*)il;Dj$);(Z}FvqSoFawK&&i{i$}afIo^yKK}b2O+*@Az z>zH0KVLR?ANQWpp$b9yUtuPu0r9klfzc6NXMm-sffvO3MjVuXRaXXv$AcKENf{r0i zW-E-SMrqD2@{BPn-C{Y5+G~6_-5x6`YmcQ6M?`?t5c}~L>v)#v&icD_D}C|3%hifR z7`GjyDB@S{ryzuL5GYcVb<2w16~PzSi&IXBr^Rj5)KXK4N6t{TZi`Ob57pX#-}?<-xwH6+cH=ZgXTmYK*5oPS!m17S$f%+#1*^#(SZRh0m$#gR zbf*}0O=s>f5zwg&`LZSY5co1oX_vc~ zHZKXqV#au%9QaV@peN!UE0GvcFG*AqO0J1bPa<7e5ykMQ4r>yj%naCbZQ@At563M& z#_}qDpI*pUuHr$xt%|QQgPgoRk)b1gw#F=ua|h`nCki9Wkn z_<1A9pRRtR7v*8Wu;nR|w21y#w-Ab5+?(W^qcAf96u6f zMjEoobm&B0ycgtGRd?PxT>-HEq2w|`6O=sGcB!moT-CI3hyn>ZZpQv)D&<0NlC{s-qaJPdvMKriksv9sp-Jvc;6tRt` z@oHA23T(z?Wz8g28yRV@GgqyPPesCvs$|lMn362Y8c(HJ5t@^U*>agavN4u5h0KiBJd8ph5tE)o_VUfGofw#?l0v&A zbOOU0fzZs&%tRw_S_bWpD}GM z4$+3@)p3n?RG86}wLx%%+|D%xTLW+piG*D?B~wgW-l_{NGyZBl@DWWHh$8oN9gBQ(;6VC8sqF-snI-qqFxsEYX|I}?};MM|9YOE5)^<16BXZ~%SnAL2Q6YVWAs1gH*>Yq2F zd97dFE+}tmScoyNa+Vd&r@~v;YMko^vlNFtRO*_PR+zZQG%b|ODmzMLoHPDn=L>U& z=ry8xoB1S?FnAP_HuQHZ1hn$LUJlNQnTj_k`^te2mjE`s_rS-f6h+Y94cXAI( z5(lr?ZiNez@95+f-$Fo7e{S5$Oaf?Is&@KlkO&s2bM8?iI>TJY4LhJR(^ivNpv4B;#& z9rc(2jYz(MXK1Iy<*CTvb;lrZ!HmAmnf@2~N^^N(s+keH+>%@H?w%pzXgWh5nI`At zGGh(-DIbrbZ$&(bb%!FiGbolJd>l$@zjA@o|>eIH5g`TS<9VD}Js<}R|6B-OLtLWEvfUOX- zG*k|u5au%B-UP5zL80t*6Oz?lE{sbc#@~tT=NZsMCSof3JnBLEzP*p6Vp63N=jjv3 z8vGEHD*V*~dJJmJ-z_yv13vefrWp0;S*k7mifHKEoaJw*aO^*T3+J4q03G$j#X}tD z=y{4|8IH=Z&G3Xka9H+Un$NedTr>xTd+%re9ea02_2-^Cb zLYiowb9e=MWBT!F@~I#+yVCA855Bl{CNg=K5Sik$X+_2l$5@KyHVY_d+ZO6R6x>oU zXjcx8_)O1G5uM?)VXuA&q$b8;x31_VmK?p~Ho4ZPb&xDcduFGXOOG`TQ8qQk)L+=7 z6x(N~)$5A$9=hth_UY~GW>he3XqzhEw95`?%YJ=)jXpN&J@eA;s%RRPhC#^j%-;bI z?`-ddR{-T#x$#Y27St}p&bZ%YhCFe<>6cD>acgwEg+6gF?4#v8xy0V0BD?iMZoP)! z{&m^LvL2?@lliI$FRc|8cz8)~@DF!r=J#7O{&Z{Y43}F~kG9Ik$Tn)xy!|>I%^_3C z26E~*Vjn}Ux;~89TFq2?nw#E-r5Vn4IRbAim z8y>Jw?e>48`TjS*)G)Cy{f{-@w$`@uRy(Z!tbU>RwaoBcwn{!0x$H=;HC>O##>~?P z!DLhI-{+gW65jIfOXxe{qL#~=SwF5>4_YV?!7qV;0+P8aw&L}2b{3sky4|jC3e^!3 zM5V{82eRfE3q$5XRK+mU^wsrV=N>AIL#p5X!SvT^A&gXiiwoKo4Zm%dJSV?iZT8n` zGti+ztc`24=lsdu?r)3cq?9b{6xrq=W+P7oZ_m{ls2SOvk;bi&#<-h$uKKTQ+h)rS zt806=PdjkhZ2Qj<=j)DI;w9N#d+yn1X4R*~bb1HFJO}mXJnuEH0fq0NMKIZ_%Uv}n zG7!~lg?%^tk%sz7l=3~RAWyR{g` z@BBZZL6N6iyKk3u7h$bC_0>1>0t_tv0<_q>fAKe5KYJaJLmlW}3vq9JMk}z@JKC+l zcX!*eH=h+#n3)}mAH78y^xdJN0fjcViFZ_9bKf?`>&pOxLUY7wFNI>R25gM;` zt_&96iDGh6z>TWD#)=>Dd=d75&_(ny+Ms#d4Qt>*fiJ;j_M`x&oYe-0JV8!BXJ-Oa z^hE)y-Cq8JQ$x!Z)1P~3-^CXWT z**1UtOxI)H`A*rYcZ6@(|A<`&oAO%$_ufBgQ}i zY1%*Qr8(hgp$ETgHPI7*mhxxcY2O2E9Ksr$H4%v1zf-ra-{iWn2 zED(+Chxs?}C|&x5w7uZj9XA=!iAulKEy&X7x$;l6PV=A6jk}M=KiY5_ebHI@8r)!f zc0-dZasmVtu2$DXtBHTO16mDqg`m0o{iWxVEFiV30%OMVuw4_J2{NUqA{pa{a}FVC z7=3@2o;>*89rbSC@}9Q4i=Pm9NBa;8DdgeD+)XnByc3qmY)c#9*C9uQpushMI& zk$r?TiL~$N8bSXc*YbAMBNC8Sv4|aJBD;dOtuS@Mv%~NR1<=D!M$lF)<^3P!4=5f5qwi)VsqYA`@R9b%{k0D5@q8RJG8nLn&BVzcST zBd0&OsgvZV+v+b_(z% zcEiE^qJk|a2*fVDABrxQD9k;V%1F~{F_#Ppoj#d!a*ifV*miJXt*#aiE}(wi>nxKSdI8xT`t6x)TTc4U}!;=){6vYibHH{$ZB)0LnwG zIdWhF*KCmGb#j5#Nu=~NE-vu z#r)zThH``BP&lmaBJr19T717ucy+a#$I0XA+m@ZuhmpVEP+*+ZpG3%R?smeb8hJ`x zh&!nl_o?uJg|vCUfonzbVI`$$JZ|3I7UUlmw^c+kzHW!#T(9PyMe+P{Zzw$9dR>3R zH0iX2(?6O9$Lkt-7x!@64DalKat|F+8T}(Wz+UJG6uFV+Oobf7P%9NVnVtk1 z2m^o@GDAo521BAafKtcr2XCApAuCi37_t|FNoXRZM~wN9n7Bn|5{8sAd=Tzfl!E5! zq(tlq(vYWkf2{<0?wdtkkpBb;lE7ApXA!|g1XD6(qWFSH9n{dN5)X;9_IfpLJwl*O zUDcieEipci!Td0Vf$Yi>wi2@G6f(oYqn_eo1`U`Um@;rNg!aa#B+a>@u-8U$L&P2> zClN_Yb}?0~dWcfb^}xyyhbN@RC@L4-c$v;)MM(+IrbYFckH*b^Co&{C2YEd|-6ys(KxD1IyVkXDRh*G9LMY_-+*QQZ$n8ft^Se2ke`Uj>*D|%C7 zlmO0(6o*koJmbqyZxo^a?H+aoz8Bj0b;hUaU|^s9QQ>zfh;> zAxlc3yuOnSC49_*%ch;L;y@6$UnM-DRtkDXsK6B_GY1{8^8sG1&@|Ct8 zl!!6~k*Rmag>icxIg$lAHg|y;SI-}q{AZjPDsE(&18dm)YY}-8l z`&j^xgbS47Ih;!#5}Dz;o&lB!Fjzh@$koYOJwDh~hy{hPFb7wz7X<35@WLPRLq+h~ zF@{>eiPvC{7?j66|1%Vxb=U2(YCFd%|F5`t4&++KeKQ;nF$V5|KJBFY5Bzvz`P6@B zaV(7gJLjI2<$vnjFJrGe5x3pz>NCa{Qz4G{dQ8$M*$&tJX=+RjH(5_^}cxh_irM`Xq*m_O^pMxecc*3!wF6a0LH3{FFW~~I6&+1)mAXdq2zl@j1P6lqOjffRQqyxXiI*)OrGsY>v9;ftc$+v3{n&gF$moc zqR`gaMYEr*m(QhBe>UOFT`eabPoe0oK}$CKIP&)E`gu93zJ%fXCpxwf@XxRCd_>^z zt0GT`2w1XNaej7K9>?D=;1J)gtT(ew0udmV;CnLoWvhqJB_I^#F3XpZ@J-)8o?jcC zIpJxaLgeLPpB$9s9I&X-7eDx7+BLh2WmIG}82g=3R&W@_a+IuD=r7`9j)#{KB;ya~ zCFFR5yc@ioCu}uY-5*aJ5!2u;AP8oBdGkU~1Cm5LJY8N03O*saJo%vH56!$LCXOi; z_S*vbLBM%ckgvS_835m=5oNUaR47TatQxauk?qFaQYdD%TLDLancjcQovu$bigNXj zJ&(B!b-tiVrWcoiba@LLeLpq1zYMpw;_Rx&T@bJP`?=SGe|OUt*PmWtlgLZ*c1_hl zI*mB2`)$h8LY7->M*ncJW%37ssR^TAjWt&WTMH+y^PYw&)P{YYCZ|VizY7|<-#ZS& z(QLdf1KHl{_Y2_$J_F_;hXm&GCpkYZGyTccbb}!JBUy{Eaglxgu>KKJ1m6OBE)E%i zg`iNG+j?G?;3+|GJTUoMq?xK7ox!}=)hvry5I z{iY#TvPa98849Dg^>U0GsCOjbDBgaiV$lI9g`BbJ2QG|fFf9<*jUrBK&?HYMS93Pz znn#EZL2{-kRJS!Tb;tL|u8Tx9kOB7`ZJCLu0OKHiysNHyyeX<8PoMT6MglzNuOvj7 z18H+Gk^$sOiWVP80lGv8HIiN(e$@vIc~Co+V9s)-q>iYulyN`j6Jefy+gBJ|` zsQekNL4B_r{%8e_ImHOete_c%1@-Q@P$l;e{z!C0KMw%|Cc9o@q4kaI3>G(}oef)d zvGeboA)h~#jl~Gz2>f8yokDEzXM6#-oJSS|u#Y+LuA85zQ+5(syZu6;tloVNR8onS zD+XmYaWL`7L=pQ#Gz2|k;GQCmiv(`y4SuGmc$fv)!z3m|hfGU?qrkZ4+Xd-JpV!Pi zL&ykW5qK0b?%l1}eFZ}uc!Xm9Tnq&aGh{xp!5&<{_%qnDW|U&*q?-U-DfCEW1OwWu zYn)&~uF5TQB-#EHi#Ra~t7!iCbERvr!A@oZ|Ii)bu<><6{VCq5~0TH~^w9gA!oQCwVW3?Fx7f4^;G01$)LJgFgDEpa8-Dwr_JP|?P<5Gl*p{7^ zm(EnaDm*QkZ!!hD`f9ccjp2sMh$S6fAZV?3OG7MXuJ5ID_X5bB2E2>Ni1=oZl#OH7 zra$O}W&0G%)1JxN5G`$I$|gea5R6@p#!MI}+;QoY%;%ovuOrksA)IjUB=Q7-^0~-8 z@;4*3y8-}7+R>eXwns@k>trK@{aef8~^#t21AjX}W}(CCpP zcMe#7_F9Moh>y|o%5%mUX3P6>O*Ha8i%gy)J}?Flu-SJ*EZ27?xOaX}9cyS)A{bO# zbv~F{_1d5uary23`C8p2g;UK9jCyN|FT8cm0a-zy8FLmKoh=oCA@_fB_^zJ56N73& z=C1_4sY!BD$>`tY(eMRUPT8vJC!paw7n>n3Bxa3opwE_<7(nmKJwuB4(D_3`ea^5a zB|uj)!0l-u2F_6{=#ZlJ+SLqu7A_gapI45kU<4#cl)9F_0u71gB+uvJ8fES8I-8VB z2|>W+X(01?(!+>qPQT*rE}$dR#d%lWjPEqEdNsIj@OLFO7AX2!<$US680kXj2Tw;t zU$Od{n;K)0C070U?GgO2^AitmgM?o$tmH97VCqRV&!WjT3=z87zjF#G^#h>9H5WF>yl|<|Z2V zfp2&7Os{Na6%y5ivLbFl_nMv_gC?kNUu{Am9i;|0A!G)viL8nJq-f=6WoXUE0u0!s zM)0C&%GVcn9{IB?kff3(7zVe5#8Fk0N)UzjM;i%&%xu!kkxxky&&M0Zz$I!iASRrh zE(BZo!>Z3;GUmZD{J4H(?D^A(=J7=ZI>!JKCZQvYt9pQICu+luZ46k>bkW51 zI^~S2gqA<&cx+Z%3qGs_jI1cmzU-An&9@eruDCBSEU*qkSrBL;L%c;#&sBGoc&`8n z#%6`b!^%m(eXPc+H`KziP(cdhOjzO}p*S06U+BSK}<`#}8{L zFMh+EzgTmRwZLizje}%8Ww>wbs;qRfsC6lp7pV{C?7`4*aMs6j^Udldl0tC$S3U(= zwYJY_`=&EB$m^M8gLy#EH{A#uBF}cS6RG#HPSZUlq*wfj&31IEg<&7WM%;9`g3QQ$ z+_~X%H8dDp6FU~L@XFqit$@DSp+qG%lqwT} z1485fkPHvzoX>Nag}Y>4WkYM`irUU4{_L*6$qJ*3{)-T8h;^A}fe13Zz>x&WwfZwcJK%seRZxKDEbcrm!%#j%Ve$^)_+k56`)Z_53iS> z)Rje$-MargNa8o z^m5~ARqF>lGeQxvPU?%{EYFM8b;>l5*vM7qlOv^v0TJUJbrA*sb4CSuQ}u-cs~_JF zc7_NwB3d>Vh?4-VmQozUTo_bQF|Iyv6@^jZAi0O3T1oZ8jWv{PO6sz`jHEK| zjop_yBY|@*o7w$_A9!EdL|NON$jpwduZ8NXt^Rx%6l8=Hmk}dOdq4#0ap!HEPND5q z{4M`!ckP$HqtOUv@GhtMW|m|(DCHc7n%n9tsIud`BehV_%JW) zy=UT%TyfEd&nz+3#uQlaYw$Mii}UfW6*3wG2g%s|ALOoUMBnJQ(X|%rBiY^He%iqT z9ADU;VAtFzcD8vmqZjS@JDq$0!^ZmvwX{dLKTB=N2b!o)-aRa>&bl-n+}y#7>dBX1 zvTDhv+(_E^g_E!~eV-HLEKVZl=)k1Z4lnnOcHK7+jwM9lf7#7({Qun?8w)q<|GJyI z*3pc^RAYg>2O9XO)68!ymhRB@Rc$!jWPnt*e#9p&T{(e#eNqk|~VM zwdH17MI_1ExiU(iQ}a>%6ZLHC)%^ zT<@)t`yVeqgBk1(yacW1(w;nm&ngjNW;wdG8L56&zr6b0i&k|Ey;SR)I){H33u$}Q zo2NOqo;u z7C^qt)lk*w^-0m7l|`zRt7=(H9?n>WsRvy<)uv_2Wn_4pHKmo*ZSB7#){6sp#;jf1 zVwO+Y22>CKBIlrK@{$y9y=o=S{RIAF!7<<*bgr8whegY}KrL+CG!-Qf?-P6e*50fl zOov`m{CPk|g1RY15^OUhW{h&G>9~nK7|p+zSTw6pvqS};$U1mp|IZpLE>5slBXVnh z>=I7V@4L$%%_G(>28zh;09NA*|$BZ;NSu&VL^>l#})@O@&tZaa6oNL zn$a=JS#5AJx=aMv2Y@1Hp7dr3;D%-$DQc}XO1X0&mTVQ#sAx-7C)6~ns-PUW>>2+6 zm*btadBTA&=2ww~h=d_O6)$5k8L9a(Sd{DK6HkGBI?07zt{ZSIZU^kkIuW9ozQ!}emvZXHVGkn_!5P-`1Y!nT#+;f45!OHjq zWvPFRx5%WH)O<$oP002v3NNl*S>_~npb#~oJ0KD`W%;ca^%)##8lBX9t`=p%7%lXH z5E0iU-ok-XjLRm;xj>Xc;kwk~u(|)r*hwC>Ia@#z>b%bH*%Iw_4BW&t(7a`6h_KN1 z>(K_u$4YR=o`2xdqwVklveMXIv6H&+uyj0j2Q5+*?4DI{2*s)07uL)w)aM*8Asak9 z!^xkuubRPux~GmSo51&K4OIsdR<6nM;0H=vG*Ih-Xg* zCLWt93T!ITpf=S)9g#FspdXa0xcx_qY+OWA3he11i(ZPeG!aX(1~M(NcYLvJp8I*N$Q$4gv!lFDuNyH{@%o5TcUxrK zyh9HIargxNoVjx4f-Ix4W{W^m5O8>Mq=*x;Sguxrqq$!(4kC!7350f9Q!h$uy#T{2 zdrdqvMqkjnqNZewLK)R?Hx-Qn8H46{rI@a>T@)ex4;*8XKKlbeUJ6{fWAN6fxX0VY zvk=BZ-}q?1kV>`rD7FA0$vW)9RkvS=Uivq31RquM0bQGa|gL`i542wVy(DBz;Cpe+ccM`##|YX_*c-zS-OSp734q+GDnJXQrVWE zOgX7+=#!sp4)4(}T|3^~Jh$%eMO#wDX|cxJLd>hBSvNG1kAodGIuU=+UFP1dVNG{m zv~H@?aMzkvS=^+2FgBVOINmWI`IZEpN3wr^>U5Dt2XOWc2oDhg_7Ft=G1*$(+lyx4 ztDN}L?cJ1P1(cb~GL^AarX0Wj0t~K2yt5jFED#hQ{_syYM0jFTFoL`?#hsDiJ;8~5?pvYCkS z5b+AxN{s(2Uo83@t4@?2Vp^QFWhb>ytOK#^S5(kKq0l*~a+e_W3>(sdI~NDP$1p6_ z_}d8LA4T*uW$&Z|t2ve_9?gp#v1{jyBt!l|E!nnRF}@?Bgs;CAtlL;@}a3&)8F zo{;j&Wayhm?>5slZamX};+rRG@k@xdC2>70X*@#_Pe`RoL)93?tg%@dc~+nUPXcuO zFM!r1QY|H$Yt!)t8KM*yfz=1!1&iKSEMj&*rXbA!YJ9I6IK6{q6n((hEiVutb2>W-9n&UhX*ZiJp74Ld9BCsNFe)3GP+kG0 zjZFqLUI82g)_oS;as9NXc0p76T;hfnUGBb*NTmDBy7D8T2BgkD!3h{G9S#`(x)79^J0R0$r2kSd;Mdax(SRs zkJcRP<@NC*PcKw3sxZ4%bR^Hwlv-7@o0%gh?n!dU6UP)k;3TZ?6+H^N?m-3>BVo~` zEdoS7=#DyRcV4QuY6hkha(mRz$XdV;y^A>W-Qj`>gy z^OY|HRT=VRMUzkmtN24jm5(439l~00lUS$mtHRENSB5g~pib4knlXwTQ#M<&A^>{O zM+j`UZ^=s zT^jBajrD=%l;Q=HN?L|03#$UxAfahRHsUy`xehUB3!?M%aj( zA4T8L22uQBYK{*NequyBsYr8VFB^pe1sM&OVQ8L%zVtgN5ta_^H!~R?$>sBulI_vJ zIrCtM%U?VA(g;S0q{b1vhRzk}u~9OdbG&a(#eaU2cx=ioZm9^e0fJh~yP-=l+;3jdc#Cu#)RS;2p zmzDN?bYs)T;(68%CV*4nDWzK@m79qYSPQ@lT6g-{$s2ebXOX1Q6_tkpMMtF{W$+Ty5Wia}RxB{6 z*M|rtf?v)Vz~z$vmMO*)_5VHxg9jg#hTRH{F}li%1>boiRnLZnT{>$1j=n8D%l|Fb zKs6*d8!S8IL_+QuyG%dbL9-3HvL9uJIPJ_q45j#ixGmJhVk(-X9*33mVb5V^IT*zT1Bsg{WRrRf z;wf!a{f;p{n=_&TZ*(J!;;b5>)6wNuus1PGVa;($F^2}LdNdde4)~N!xCg-MI^SJ0 zP!k$ZNy48L30d*%iWxNuXhmbB)S(oW01aQ%EJ(9WR97J^u}8|{Wf@Jc8Vi1Zy&q@U z8@H#=jSbDXCnN6g@XbN?_ho2=Mix0=6M{%JBafKx{w}pygtJl|zfui(5TpIdB67ed*TXNoY%d!wJAfK;Y}vlr4kpd;X?U+c3fobzonY z#dxs4HEn>wJaX%WJjyn3p(;pE7C|tgY7MTZK-eVApP{v{^R`x|N*~_YCRHX5(6Rx< zgDHG1`G~XtNpZVhR%(Kr!UqF`~df@egw9jCd@S zIWQ<3e8gL>Z69Y-Vp5Q1Zj!<#{hiZPrdCtCX>g%_K{6;qVX}cym)fC9{~)YAfc~c+9$amiK=Bb_ z-R@zHJspB7I`Z3q#_+*pm?MAsNEI8A33K3K-{zA)+weWm zEjFccQ_-a1u*fk?tw^`xil#C%5NI1@!5OLJlE%Y@M?0rhuy^lzFysT^dCLTC{F{2i zs5dvd|0ptL-b%59${iyw43~J{oP}^dr1Zg@$QiCw)>hnNpBf_Y=(`R)4Kb3%OAuQ@ zg1Q6n{iY2u9{ZE$DUcN9_r3&$mnVQ?J40J;4U6X>vatB`?2OvUhBqy$J{1r$c<9Nm z2hM4Ub}{lV#lsnz!B#!$-9#f@QKS!=X7EBMjCW|nnj6cuJB-4GgZOCuk>YJ!k$W6w zIR{>m?($n4{0723%zvkYwhw%Bqv@Lv&KxG?|0hM*|4WIRjfL}nrg*u=vr5`(1$6m^ z2)MY%AdbE#NSHawA5u8zyc{Cta1q3Lk3CSY9+8}1wOf39VZ!=LNY4k6q{M3b0SlpM z(LMLTDm&kK3PHx*ETnv`dBJ(|7=V^Vs972WlgO42j2!PiU^?4F&-LQ|l)16Hhcc1^ zilez|4EYE?+;4ARW^;GE?%BF%__}bICL=J64BCk%5ps1Aaxwe(_&fktyy=pV znOvmRdFIe2M)s58&Mfj#O&9xQhV>tBWZGFnz&5kMl-d3A@)-rq@$*h+s#h*oa#uE2 zx>wk8ps5gi@M1V*`E-c4Qj!ANWy0-AL!#@ z5{@>T*(~Py_J=?b6GxKQO(&zBtb087Jq*(DU?6=EmxGe^zVYfbo2wMCu8_Y`F$_n- z6T>9aso*$1>513A6}8<7+$NEt(Ix(2i-l-Su=Z%Y_3YJDYE~UK-x}p0=M95d`XR=h z#payHfubaV&&|U*fBNpK2PEp1%D=O(Djyk_OPTo4a4@Ng>fAAFO>d_27 zS8wvba!(m78#*`X9Kv<_1F&olubK{){805@|3) z=RxpNWGo=*v$=Y7{fq% zfRY)FJRmtDN&h`elX3N}`Rh=aSnMwmU%*;RrplcU#mql}%lcwd_^>BaA8J?_tIMy- zO|#U{7$3oiE!I37`N!plHm}(AJ6tMLIm`i5J8CTPi zgK5L4MhTKSh!?|N|W83ac_rx%bh<9k@2kM1NMctd8 zvHReqpksQt;`^oS?|p85J2zm->5sA7`h`kD7n|fD1#%m?jPz&0k)s7`cHe|3>g;3g z+Xp*tIgdiBW@BMj1a;~mlLSSRqWsCTU4SoA^%M|MCGa1nCMh?ESulatPF-Tr8kD}i zoZ`N7nbEh|6%b3k2S9~cu|fbi^ZN2jWFW5KBEaDd%I;b?5)K?3045- zj>$6UhzDhZx^lN!g-~n+jyx6e=v{=MyK|P!nm>1DpPNUi4gqe{)IWUp&JT1~G{GsH z7gGaTvvfkKba^NY49=w)GpPd>|Mdw+I z5ztVE9!&F%vikU%nQWEE`~vQb#Ymm=>c+svFv4-Ta*O?&aWZ#r&reZQ!Lx_ zhEqIkCN4t+Z!alOz3PEv@eDl9=e!&)(f^blG;e&u>BK6pc71BewpWLEyr1ueQ>t?UbT5!(x zmuo69q0Rckix=62`?JYd##$9(@%wA23vY4Zoz-9M|Ep+deZ?5idxBnNiIu=f7D0;B z?apMYEiKRvwOwF@D8xD#E$s;`!D$RvfjoiHuBVenYvbxYcOjnTYrq>JHwR#BHSYC5 zDR>esRO{Dovtl$nUE8fQypzX1hiT3Ji|lS%=Q)O2y)o?W2N<>OsK%#?>`f>)gCYCg zw1or}e=pXY^%)TeA}}zeRtx9m49r*-R{|ugm~szakz-G}at~fH#^f5nE|`m=6y*IC z8b0ZqBylT9sTVHoSepxH4~S4u;!Bxpc!(D;h7+PY;)9hv*oUV|3k3@cXqA*xeafI@z_;cg7R8*NT}(vd_)j!eVPAX}HcP4Qvj|B`y4?-45aBbT3#tnk9_ zyf^FeJyD);Qqx;LRE_M(J!kbRxYfRT#Ij|Exvz`@uM2NOV$m>Iz^dL;pILtwzA$g; z)nOceq~7sgqt!J-G`PLd(gCdnOXbj9R+xi9f9(y9pzGO86=y*9kTtUu|&C83C)GT zm7P@1t8agG+&gGa(ReXZJRAiJL)fH-GuUW2O-~{AXM7rt+$qX#oKH8C#YV_qY+?-W z&cZn>;uqIp;P(9+1)#x4+v^6DG@#my0x0i=sgK3A- zkF6TsFmoZ>Nsh{M=@3WdaGeu01?vA4Xy1 zyC+05DjbUeCus*4jjI5*zjQh#A53=1P7%_AD=_+|OLw@}Q-NGU_&Ilo05e)QENYwv3*; zgx*m|Yh6`KRqY9)KGuSoU1n9rT@@;H`rInI`&-n|T{$Q%CecjS&^__BbMUU1IxU9U zCFDTZ@Kw5`rIu;MGftFKUQi>7WMx%Os_nqQS~nsPAay)Nl@M|9U^F(69v{iIb-rHD z9`2Je?k7cF-1GkS2!Veu!`5Pq7w3SN{p^tTn*sy!7xoHsvcUIKR z#Wp^lYpiXQwFUMrs2+9QTO!zkv?;-(+k9vM1r7eK8hqibwT&~J;K*?kF1Lq+_qSQY zATn>43EHMlT*y>SPakmIeY<>hBlP{04~f&uxSYa{&}dOOeA=!`}C7vl?po6>8tjaRP}#ki24RDEG{4w~5g zsw9JT>->8iXZVEF@IbI+t)c(z{a0~Elh~zvY7cvOZcU}S=EcNZzL`XGW#=n|Xr)pO zOJXG-KW1F4b0Si=i1}QD?&Gz4?C+RPt%7c$Ny386R9>xVnpl_DFbQ3>GWzfy6mUgI zdU$hk%HP9-ckf!q1e;FQQ;~^<`Ip>fPhaY_-eGv2YI4g+O*3VTGs>1mWUK;7OS*cmR=+vflo5C zn7!qHCB8hJz-D7ee>qnMv_dRM@6u6D-hKX!@kwqI)Yz?z4_!e(EV>$KvT2lnUTe*| z!iOUvE}(8`Rxv4M4?hy4(ScRO1~7kbWqk8nr+hn%gd^p^?AHiCCVzWO#KWbgy)O9a zL+@v~;1bneoX$gBP4Dd%ayl(ug*GGzBWT7oW^{| zrpZXbCGn!t3`AW04l;)|WMrIy2P}?-km#t&<1AY$Tdj!-6>YZv*|ndrZj(7VH?S*{ z+1+n>cbwRovs}}4ys1`O&}H~1cQbNqV|Po{u-2snAcsDE_T;4LH9OY%+9_9PP0{*u z%9QGK_@|6S$_nY7Cj6TcZ5Ewb4WHE}5=9Qz(E7D(_LZ_-%FH~IyBgnkX_?;gLaB#L zMLq7WF6T9@^Lj;;iVdk9us$iCA4OB z@Z*Vz1WJo&wkZo~Bh^F;JbjB6a%%cKFI@OFztz-y4NQZ<{GBIMRAydbx-&@xjc2DesVEc z-o|c7Lwgcsfe(_(_QKeN(vxuPT9qXU*zEGEvsgZHU#%C84e_!qoU&hX0Ci}W-i|EP#2?ZW&9Zu;~e+mjS! zwcO%)`E$fb!PKXnT;h@56Wyy7aO?cr!S_P z|8dZ1M1c<(M@Hfzdcw!(!JWgwXyzV2eIaj9*f*##o4pJJ3A>)hw72kE#_%ccA;>Ta zingSVe3jK)8GNxVwnw|8h_^9#C+K!);Lp`nyovB1lD`YhP~brgX^jhVGR_d7<62J| zWIZT{mYpyQS>W9+Z&I6#8$DDKp?cM}%P3NG4y_|ykbuL45JeMu#3tb>IbB~I^#!;m zCQ3lxaJHIrv=(4}nNWtN)#U4ozH3C~ji(Zx=C!{tJsPz<> z$@rOIr*TEwU8Tm7&bIaNOc<$;l6|Zj?I6(m$FLmY`Jc%FvXK6oWKu!!CWZ@rD25nr&yiNLb720D=k-_1w0CH#6h?7fqg-o{Mn zmfm4ZXQ((nB6dPddKJ?*US%ZyY0d{aW;Um3&bP@k*8yDBOmH$@ZRgJEW?+AM2+xklUC-j8UR)=!dbkR*-ykGgF;c@FQE&7XU z^Z1wy5xV>Ya>P&ugZr(y&XT5g$#SWo4im9Ua-VQMFzR|A1E0{B-r5npnxp6&>%-3x z^ik<=9NGqI=c;7)Whd>|18<}b7xMUIfes@bvIIP~MKwWYwXxcNmHiU(Qu zTItli14yAFuk%4-Ak^*@!?R1tCl59-so0E!qQXI#j>cZ*SiqNsAH+u0a(#95ucL9o z_RM_M3iZq&om#Z!1{kkMwId_&S8yfA^;$FK_3ee-ww}A)+;!!@i@mc`OcE4~#E0Wr zLFT~)S&s6#{|+jDRY>BiMF2#Z_W#)K^OWR39iUzn1EUC|ora{ARkh40rTum*^+sWw>v-ng8|6 z?UmcG-4qyKKavM$wTldf?bC)#XvptNy2VIu<*y~4oSv{^i7}Qt>tGyWgID5;CXR-Z z-icpzB#JJ$WjWPx-n_SkGDiry<*)rp;BPV0>@*h$n*~4jH7C;z@7%O~rd95B4(zki zqek`QA`mV6cp}lh79YgAIEt8^g|h~eZVilO zh%v?rm0fb>5xQH1UAgWC#X6ycmo=V*smi%(g%-jk*GT2pzD~*Mv8WA4Rm$XW_~V`i=iBB64(;R!GAy2$9Fx2RtCfb|h&Gi;GtQ56VxtW!A~3gOYh}^f zx_UjX(SNMEjgxRjrtoerpa~lQY1>U%um-lkfwA0=E!15_hTo}?h+vk}V@ow=>=6s; z4kl|DhPm*b2}*9=jHwvXH2ZKr z^Kz?a6E*5Yhvwdf9k?Zm=bzjxf6(u&+LU$u6d&NhHHCYd z!`Zoj?Wq1#UPRp350st_QTgh$$$+c#>kC7*;us3?JSwhz&+V5ow$}k!HV<3 z5YgzAJ>#v`6);C-i_WN{e?As}nRvK;EQTgpI0b;G1zkz>G8*JU3Jnq$V*<%Jsv@&P z%vJiHF_k$~O^;$}i71$Xh9b@)f60aJ_J$sD1i`ZF#wEHFIOkG27cZ&wYoh!#5hjGu%~L9MH#gVXYE40%TZDs)`X2Z7ojo5H*V+ysAKdZ0x!Dk_ zNaBlGLEAONtxp^8uP>F?_vf&^UPSe*t|@zmj-K`xYX&zr^#JE4kM&*Mk0#&cR1rpk zm-p)(>|A%KU_#%AGCL^>l%NO0Wu9;)F1r^+|K!V^>(i`j8*g_}6lC2RDcR2NI9A5l zo4V+#>%T~7;?gfV;>s!b*-lD(pm8{eg$bEnJ98CTUBa;`t>kQuPNJBeKI=QV&|SWK zN5#;;?}2)XX4d*%FT@`Y?%ccJ5xt#8x%Iy@2;RQN>Oih{@&rBvi0q`GU48z!qmnwQ>vt}IH340e39+SyAxvT^Y$tpku`2^Syfw8|uy>h9# z#!cSbz5sXf;+LU43AHQwA6j$1T0s?F6+Ax=A{Sb>4vUcEI zmVf$I2zI|FW&|2H=T#bv?P`@HUWUn(NpFZhdNynk0Ew)U##fn}t(5~OH@04=Q190# zrax$XDIZ4ScQ%?8nD>RKlIhIRm0c(GKPrddG4=}Kp8~FLLdB~^eS6on-cgG!aDEIo zc7meQP~MUuY|jBuy8^FOvm{9G*2vZkP{Y>(&a>POB8>5Hi+-Dh5yj*Po^o2CMu2?fl-e#A`=8 z48$UtrSzg1p(O+tr>9H;xeeURdH6}aFz#Rx8s)FAZ6egqOdp3 zx|WN@5dED$!dJnkNg|!@ud|BUFAgzr4CXdh!lvcbppaNMUkHPD!lz40%GNl!HAN!-i>?2MicjeYqQ%KXiFX^2k?UWC6O8^JE$Q75 z4Pu6y>aF08%B#8VR72rjHHorzh@T72@tJd6)QLI@;4hd=x5kMlMLM$UU{)mf61FeUL zmHPmJWqkHuf)D zibYe$(er=_2Nr7IKMRMST5bsO9 z>@1fC+>O{?$&W@++q``3#~I#q$a3W^Wk$Ar`j!;`Jwe(8wwVD?x+*_I0;;^Zbj`Y+ zS4OtPs3fSW+_VG<=2pmn8O2{yM{J8TBkyd42gzA}?3*QdYtzD$R&uMgOEQ$EUl27b zV)J4%PdL#b=NDDz6{za2ixK=g$$}e?d^UG{4WRRVW**i8u_V&C!Tbc99*}TjqkmOM zx-ok2&RW)00D4gZ=+7-@Dhv8Q129({ZfscB*Cb-YFhOkWXL@HEp{qN}qhSO;79DGV z>Ngw*N)sw)W+`jQSC*F&cx4&5%V`DCOm_Y`D|&ebGMjD*2>U}oY1r?4Q;vD(XsuRL zn)&B2oK;z{O;pj${)pX-G-EamP!teOJ$wz; zggIn2B@R?bAGzZXN;P_c(}LM%HK(>z$RCOS5ga~&X~C^Jo$5s{M+Im?Eln|T6BL~? zc(4i0&A77h%rz1s&N!(`>j-2K-{(RWiE2^vax!O8Ufi|xrORMG-5qk7I{o7Bz9(wR zC?e4BNZj~P3aj&(yjm_A`#E2TBW?M>ijg%->Bqh+V}|zWb@F!FG|kidufM62EPn5^ zSW`yn&$QwVZFCI$Jt{mEvmxwhVGB1+-?IY1J3=DQj67u5SB>U#2YT^sV;jZX>7k@0ytX>H%^0Mig$kDAMw2yzK3<=V60slFuHfSo%Y=2<~^<4eN6tn5l> z)K1@7>4i2iw|$!Uqd7odGRa~|t&}P(vH0iwYx+(7QWY3Ub`!jAQ|l>E&}aphH)-L) zwesl8&MMz=ixa8xPzbB~B7*t6QZ3{Gr>isfw9N6Me`RJN-jRY2k zoAgDvXW_DOqSh$9<4kFmp|i)sXk95BSfF{<&1J-9XJ)e{FCqsT2frEo5)vNnf?sU9smg{ktTiqX%^zb6uJuzn7H=T?gr z3>U}2C;J4SZe8L{dXl`86m^+1C7lQjKx>CP)ZpiQ%C&G*;h2kcv1){sDD+D&X*zBM%`DiT{FRuKYtPA&?Kc0c zj_e~Wn%ORb6_MG{FQP^fe3*OG3j50*1EGRZ8tRs#7K2c3g7rws7pBNK&XjsI8hR;* z1A}mau|z93v>pcSmGjM%u;fCFas??>hsh+(uh{CzDP)RLV*MYXuI_}Awr2^~VN4-1 znF(_;T1r|bBUsc)7^_070%GcZ!)ID5S}UC{XoN z4yoew)9dMoiiE=M=&SxZvD05vE>{u(aEMBx61)a8d~!*RgkId%sT~~p46QF1!BDpG zNB^9={l0!|pz@Y?4ot2gvKSadpxV{}ztFr$!GH)IyE}vx3O>z@>Huin95_jX7S}jT zr- zvT|kah;yoeY_(Y&&+h z<6K&FfXhHvc(S#1XUW2BM=~TUo#m}`H(buun@{Cp^!6J)0wM9p}8IV1=fe?fuf79QM(u4Uu65dgPWyLK>A&18|^4d z#jeVb9ah5RtYx9TWbA33PX7l&sxzvN{$ucoqoz>zT62^EIs-C>wz>R3j5NdG0kw~- z^XZLmTtStb(p!Y+5I596y8$tM`Gp~(WchZiHvz;H213=t`{Gb|EguniS9qtUOa-}?? zwq0Zu$j_QS<&rw!Y$21KXS3NXXqbK)IM>`gEo!d?Kxr|861ww!f25h$&j_$F8DuJL zhg}_#3v2@)=H#OlW!rGS79C7ssRjn4GbvvNbTWcz-S$2Zr6%80H2X*-BAw%68{u|N zhJ>4|w88>HA>&MDN_53GBhjN-@SQZYEUGe8RDz?TtuurVE!uzCO#IQhHES!ONRZxZ zk5G~p5=Bah91~RZ_S7gURCqEXa27CmEkRgAFpoUuBK&EF(XevqP-zZ{#0@x!9WWfk zpE&ssfp`M`@Ej6l4IEJl&nP0WRi?wc3-q;DdUn=BxyK5LdduD3gcp2lkGe(;Fr zo<>68F4!9ER4sm)H5@0&h${!K|l zAdsg*4#3({qIW3#9eQ5R3Lc|CHnezDAu{ls7HcTZfSu~-o8nGG_50(Fj!%tZQ8E)T zEz&S6YN~{%KzB(3*7Z+zsCv{!xY%a1DalC0KJpkY>lK7%sd6Gs1WHxj$Ua!pLWEL- z>xvvaLzQrt=&WC8h(}i0Tf-f50^i_Rtv3Ke^3l9P3k(gAsWl>BkanR-UIE6e$t<~w z>%nOwe%z2bGy>U-;bckzk?cC1Za)7XW{Au~si+}W#aGJ|5NeQWG)awysTSQ9zus87 zf(0DE>fhwVhE#hpmvySS&x7_t)TS{_4LOrIS5q>4v?oza3OUN&M5Ioe@nmaLjH_g) z7Y9h78N_AOeYLkHk)rqcFe`l|72pzU;H#x-Of)U3jo-v*>YIX_ktIc(pXFKe$kY6} zm74yd=>zsuZVlrLBnFEq@y5dzOo{iwt+1#@sC*y;0~G5C1F=rxjlzEiYzW;A~zS(A<%6|HT5|Q!t+})hMeX%gW1I1VoK(BrdOhk zYoY&+6*6|J33R`u6)(d^?C02#K}}D^3rrRb@t{;64#pPkngdmtJ~=R&5vn(9Md-hslkgJVWQSLgKMx3K!lk&Du`F%oz{N_BIebZ(`CmN z#FAc*0lF0i#MWcPJs_?gf+4aEL^3KZ4E&r^WJ9#)6Tr#xZ*6id6*I<${w-FUhbKtG z*^}5a>{`!6TfmVmJ>0Rir-i0>G~5+-2$s(I@44|bBAeiy+S zsx4lu9#ye|PEiop$d;>fij^=7o;ybx)`8R zR*HDkCv&v)4Y^iuSG1N#-aW@ANf44h&LlOg@Hu8pVX`!7ph9bAB8p6_)WYbjiNH`a z40aIBA1N-<6~DcxpSEW*k)&0m^QP0_kS5gb?_bi$bEe&dqD+zcXG*2RBGYj@em*9b z*xVo8f|5n~XkM$=Pl^fE7*WpX$E%4AQyH)q!2S?QNejQtrV>F(3FIe*NR;Yd{$0W& znBdjilrE9X7F^-5xx~Q;p#@l(ZX!jMj5j4BtPA>FTOX)|dBs%|DN`I@A>%UHMhQ1AN$^^tA%lsW#lJ8S(o$PX!Ar_YwiDpi!V9H7CB{MZsjr-#@II_NL zSrG>=JPb#;iZp=-yD?D@VkJ291Hs^?w8u;3k?5gsK?dtXnVEtw%$2#7uq2esV90m( zL)KE2UA_Fcw78oU^LVp4XIKiM82Px@y9mn&f<0V%Ac%eJ)`YJ(q=4{Dav7%REL*p^ zGSpX8y`n5pDr64sbnXrZ3JNWV!xd<{9!<+yU!nGj3Zto`$^2O93;|}rGIr}p^d4cb zw=@um^{V0pG~1Wi`8Ub~*D~W7KDoTLP;Or@G&YvA^9tw>8{Bg64Ww#6NxGt>c6XJqn(jSx467zWql)BxNw@=RV~la4JJ>z*zk z8Y5CCrUyBpUP(CF$RsyUCV~7M8hlWXf+6K?AaRIa`LhX$67mVEeoJmE z+Qfj7%B8t@yS?YqB{*a;+3Mt?RP>Oo*f!s06{_N>mq)8K?hWVp?EKOlUd^IGx%!=6 zDa)N+zlon>8>$jjbHoeI(wrUR*rj=lvvF7C3sXtN3l!aCe1@#Z)qb}YsBG6t_1%iG zwdy}px!z5J;GlJ#oRZd~aFH;R4NSqpP8H81Yi&Q#fZhouN!tLj5|SKDwWY2D^2 z=OuR1vwSdD{L8U~%xZPg=5trq1S&vpDaY{qJ$W8qq6*?NS*<^gZ_jp4-29e$3pMy8 zs-%mTXttTTig;;kI>BzhiBl)dyJc*x%GT1R2(V6%J`iz|2=uA^0j3SK-Tlo>uP8C!k?=_NNfpk8%b%zVB7`doD+due(7 zynoJDe~)oBqTC`*hi%hp+BFaxCDXY8_0dnveN%MpkCm;iuCVUHWFNSFGb z9=X?LC;vW}W~zh?S(zwTm>VrfBB0Mwm;$RjUOMYHjft~p|%I^((>b2NeN>)%t&=xJ&#Kg{%Yeh-te3;V@&JZoqID!SKkCZQd@bvib$IhOVL zJp=IvlFjWDZ}{ZH)!J?zC6w)S~fq>67w zAbulhg``IeDXR49Y5c$ zPIq@0a-w%L!-rAJP~biL15fO@#mkTlJ3rsew*`O{rVH$j-HX>M3eL~xFkY(8Z4ge^ zJO3UDnDnYG{?7zww>>kS_GG+mflzR+>VFkaaWC+9e`hOHIU?-wBRVzo4?TqALb;QQ zluy<#zIWxFqQyxH*|PGywKw_sf_JDkd%Ur~ZHYKDX%$TWxR>ToJ#IChbl=mM@^c7V zrG>~|9>AMq3cVLm4HwbMaz_-ft%G`Q-H7nyH+j_a&c!7s%0E8zjhGG@@WC;4*=r?x zUc#)p(-BS?H>-awj;Au0-5GSGc=b^T!DF=F0KPgkzu}yIYiJjOr@Wz+?0C=a1+FK5 zyHYg^mN=7V3vvWB*N$t0WXQ!Ng?7G+w>ZlJa@EJ+i| z&hWbD#r&{|&Dx>GVy{VvPZYy$KZQFo;u4DSv;HX-|7>rS4$=eG%B7L0@XV^Z53(^A z7q<9-x^SszbRL(>UU?Qc^CTqN9*Jwo`ZHW<#xI*#^piC4@m~CkTI#1fFrUxxTK%5_vd}J4RtPGLcKR4>rf4fG`bIf(yWa|3P6`Q(xKc_SeXn zljfhB1JYrMjr1>eE;K7yh@;~HJVF*l;ydh*!@2hlxKAuUEv!gnxfBxhxSf0T@;fO4 z<=N1%`W%5Vex}*Q_zQm4_oq=4TE&o65WnYW4;u>%(BKI)>>Xj|2e5fl#Nt0UW!aei zb5oX;k@>%-AD-5cb~|8e*#1yAM}N;n!?p{|ND}>+aV~Y*l-zvgbekIwOf}JF_H28S zAb+^9L)8NjjBn7^n-W6O_=L!Z66mJzm%$@5zCXZp=tXBYv)j3l)Lo9O7@z(sRx4Sw zR$|ngh?KLvCd-S;8hv|HF<14rex5vDPHlbIGHBn~6II=uUdj6Uy#9R2%G>Ti=c$Zy zR00CRVpjF>c5`~W-uI@;pz-~7x4{qJNK=&zxxY2N(AwU-&KkzjVo?8s{voctzEP_> z{AIwqLCD&x3M|>aaC2RBI0$q;L0pIWlU90kx`gLSzFN!1?okKewH zp0{D}a_iBX3gFd<+DO#Lw4;T>AM^`w>2)5$Np9_m1XQ&Ah1HC5rw`eAM*5l?=6xbv zyxz_XJM}1+pxc{m?^et2;2XEeuxT_f1JI*9_6^lWolkJ=K?BfRXSY7?73Tap{B8Ee zFVl}L?DaG@^~z!ycL(6f2C`u?+dI@?29_t^Zjt{_2ArTi6{V2`I2he8wp3K~xMP-0mXFUZK*BSLJDqE$w32KdpV_@BX6a}a{M9x;DhPocRsWEZ$YYYA6#4p zduRi-AB(jgs|w3fCbx`1+>baBMm->WM8(0Xa@9u|RcO#idA1t+!3Tb)VKwW%hLT=p zP3axB?_d^yH&3asaDE4dq0<|K8q$m$_EoydecYc}@jP-3a0d>K)%Qk^XP0%koHbHw zWw<|irPO-`xw`slOqSZy8X|>7m;yXhA)PSUNch#&Ixsv<&f9xP7PLR|htXPTkc|0g zB3XNA%($RBSt^f3Q%?(YQ`pmj6p`+;IH8!^f?^7jN?MSL+iZK__aKnMNh6$^2M*x< zVlmqQ_-{K(^^RVdFa3Td`K4|h2V6cg$Q{DId`x2OJuqITL!O*=qCAJ&}t zrrFzMPr(!|ac=##n{6kqZfmIj(a-Fi-%ods0tI@^`>VsJ)YNhLv|_mz~P+35Y* zg}jmp7I6WA5jH_YN3%w#51#mwq~?B}D%UEoEx5x(GbqS*QPL`_MDcPNX;R{^m(D?k)p=QRo5O1LW52!|`wf z!9N)<30O9X&iHfOU{;0>ZtUTG&|pEb)MobCyf$AuSOz^|6?5N;5I#0;FCVMG!Z&Xl zdNYhcep}b?b&wN@o$6d`7t~J_JKh4VN(DX_?-Ev4pJrrZ% z*U^i0@GLU@M$TXLJ5HJeIfA!I&eI?_{C7g?gA%xuOSB72SI{oI4ONQOS}n!?k{I)o zt_g4dnTY#U;GsbiJwg=g0>D%?mgSI`5B_>7-Jf#-OvKgUgTF=Jz{OgO@YsGbrZOKFVa;%4xSn`Clvw(fd?Bc@pe*r)gDysCE*+Tb z;m8b2Xh@`>{1m(aKEVr*SV0i;x8-}-(vX|c03}en13?^vBQv3lK%oi%Z3wb}GxD#f zg_}^u4Ih9&mO5{mPQ4CbP^BJLUAL5e5db|7qS7nt6L{&vY8+#g^;(_Bz4b&oURPzY ziH%BMPPtyjm`g(r3vSn{;+DyEK2`6DO2&97tLW z!hn(km}B2xB`Bq`1>$&Kxu8+_C@xe50`P4A@c}Oeaaal&-*YZhLjo@y&@I$cW*3J5 z9D68louvb|cwo6y5bwq&uirbn(^Tt0oR#8~q0qdd9+lz&^TExNN_aq=yA*U|O>FW{ z6o6E~Bb*_ij(q_m`I#lkRPn%Yp3q2Ar08RS;OBwT2{TCo&m6N$I?F7>zaUBlfMO)d znIzs=$!Nn$70&=1HL)0I)yKs!^41P$w7m0X?6E7UAWE@|Zzi`xh9v2Us@$2!MTVC0 zE2Rt$!*~b|;KI@JvQXcYN}#0_*GWaM(#vv0uO2GDmUEBoeUD?1zJF0PY&BNLZOv0~ zA0i_FK?X&ioVAMRK2yTyg`>D7bkA+Q$-8kKvXI~9FTWRDin`t`mTFG^ja61lh<`hG zCfI;nvZrDth!rl4MiQe5bblJC`!JU8=sF#v3~+ZEsB1BnGs+@rtqpd#yt+HbrKU-F z&#k~#%Zt_uN4loaSkDbx>J@*O`bKgl(b!B*R}G4&7lOrWt{D7070*?)~%V`%Ir z;$H)KZ9t5742|uW&vUW-21CFowg^1NBLAtWuFXesy^F`4t59&;LW_SaR`&Lf46i@mJFMyeT~ z5HfwFqU5rXxvpbMs(V>8Jx!vKD7t{PVw3dMG{#SP{$YVyhNxH2eXmMr9uM8P}3i=k|M!fiiwm; zl~e|jFRl?w`)X!cxl<@vti;9E4c=)?z%qRv1juVhh#aQy5FtrBk{=gAVb4K0DqjS7Yni>rY^{Mmr!3C6~%pc?Ah@@fKiF3}Y&^(8NQPRZR)Z zrNaCq#>7vH4&o7KI$ujP5Kgqn5?ctd%#PVrVQYK77e+J^HD4(>JR--Zq)uL7v2vEkn1<)A@`9NvUgr4> zy$)T0QrR$ubLU?rO%tjReSt^p16$byo2?&0t%597!1&J5KD*u_)VF6L_B^G1DMt~v z8<`hlPeDw2_Ydutzzzc_E&JJ;k$p%m*eN9`ZR$HlezXb8$5C?}w!}eA2O}`!g#djJ z7oBEojQDvv8N9*eGwI?W&sPp?yzB4g^ib5#$?dg2w#jj{_ITBJ0*VQU* za1C8Z9QYgpovHyo@W>sB#&7H^2GM3ioic_2r>XCE4>!2jzsJveZ)ps=a6IzdaDA@) z^7{_D&^iGkBX}o^&fvceiUN}l8lV$Qqj)@%q7~TNZ)%tLIr|5JhaZrkA7AI$kN+hZ zv5xglPmTF~{KH_JUFb|*&Q4UAZ3v2n>}CjCLJ>3uV=ts*BuNG5X~YyQrM81HuvZET zJ4g+gyHR-0m<{X^jk)88ht--UaZoB1nFVmi0WD_EN(!~;PA?%{DfwU>n$b78M3OMH z7-1*{Sm7f7ZlrcfdT?7(#EV)^+BiIEH3!)2>~aoJi43l=i1eo?1}=Ye2s=!F%(uUW z_l9p3+QQHNU}hFTO!f#|f!7G2$_!?=y!By+FTbo-qM)C|k&7=Mj+ra}5R-Vl<9p>A)^r4^|6fNGu7Wobig$#zug**4_;Q$o~(p|ipo>xyb}L>$E}7g2M5 zVp#kJ9Ui<<5=De;^Do~>>hF%Ht5E?>?LUjVhcfo(-P|brHEgdR<;J|9zU_NOi@`kT3ksu9QOH^uGBrN!O-b_066WRO#6h zVC*8DMI?N?eA-H_i3LOEkOUrAaYt*WA*KNAPHcFlFCqieQ@IlPnXtXLUSZfo?SF}` zlPR@UrxTui59BA;*DiuKh@og%;2PF1b;hUM+7@hioqdLNdrZrShU%LoX8JSPwKqY= zQLfp;j$dZurWcYdz`eH&9qjC|V&iWY1>!a{Oxy>rrQkYU5*`;XT|?2CEinFyC+rRS zCeappY8xW%wrJ3y+h)~P*>`$a;%ycvK@8$9rlI$)(=LYh>6W@5)HkxurP|DI)p}|8 zakk->+XmGwe;?AMS_LVE3}^mjysNLp}0ab zRlYGe0~?+_{^(A4RM~s;ihCG#U13u|HK=I0&{R--rP^9{T$x^TG$OI=%rKb3LkDlA zr}Jw@?H^(R_t1YsXU<)9+1WeV-($4S5ew%9oVCdj3tZ!}>0`i_(ryT27?2$uXxVV{ zBhhs`;TIV|=~!E{qU8{Urf&4AAw9+!0PdN5-VCt)XYNJy$1}Juhx1xN>#1Yy`uN## ziDucftcBNo(0bbz?z>j8)V*iEh?r&zFoL^L85^P==t|CuhjNZq$VtLb*E<+)T^N3_ z0w8d{g|4w&23NX#z`|%n(#sPlxpwDAz^RgK2|E&eMnRXtX@B3wDN6On1QOC~0{;{s zhcW4)S~XQB0Y4Fo81GlEnLNIcwhb=#ofIRH#Sl+*S)!=H$f=0DkTQ5|4=^W zj8|ZeqK?Xp`8J}3xxkWKIwhrqyEt(@NFKcw?N_AEyj1wbhBhPMdZ+{X;=$(RMZdNt z1-RGJbyaJegj}2{Nvvf}D%?N^F1Iv{@RL6Z7lr=+=`OPVXLpgAgNgIMo_*Glbkb=> z?72{%N~mVa`%7Ot-!DVMNol85=~(ZRFB)kaLPVR`ko5WPY~)cl2hY5F90|`E&V2p? z>#sM9%|OgnhW*#$O{QKQ(r;MIwwN(#*3u{^tBX0y4L{ds6X5)aOfWA(a#Wwa*Dn5( z>MLjGu-7p#VS@ktdn*jev-w@-;jJMNn3&w;^H?B?QY?lV6GoRGvvhY~OpNsm;d&q- zT?S?zWqnkrihJS&d5Z$IQz^UIbve4RW)V}*Ah0M!DbLY4=5Eof@v}C)aT&Y0deR_8YC1E| zpj3lIzW0Wtr{@@(%<9lv*eiOX)SoJ(5G8QhDOb!MC+V;zu$DCn*; zHuaZ`W5PF!O__$l_(ic%(6?o5>%pRB>heR@2}pn0Btv+TD3^hu#jtH%ncMq2D5Y8x z2Yw-F1M)gHgTLWV#W^~H&?!VYLS_RADN+f`g?0+rb-xZ$TUS2I5~X6m7m$|zg5TIc zw?sh)r|fZ9v~7Qoc4ITgAkdZKn!RV%Bucd~$qfolS2A`Dcbs5$9PM$Gsy@oI-F9a) z$HoOBE}%w7)s)S5nblR>=Fp7IYkdYq%$3^W_$*w&fYrKB*AliC|LxStDg z0IFuqlS7_1*`6sO-H=Ug(2b9fRIm1qPP-8=3>Y%>mkBoG=t>C!X#MPll0(42`bD?# zO|3_Y0IRtJp4h#xGn_&A#tt-oxoa(+g^7Jl0(tm3)_v-9QCpD3!`7HKh;mt5ZAwLr zr1h48f_k#QHYP&)H3f{~?R|JgzN{-DpE7_e=W-Qvfbh(^k+`HCDBM#{l>bfECeI#76IZ6G`|cE5marCWy1Ux1@@f6=CEKb*2Q5UxoJv~%(* z(jh?|>6oHcr$Cq{Z9r_I77*@X6G%IEiLQT9w5wn&l2#zjVI#C-`V7)3MHcC-B9nA} zk&bHsoU-O`iUw%s^sz)))(N8uWt`%_&Q;elh7oT!GKLZFZpZZ^Qk}{g4MU_sSI=Hb zi%a@=Y$9klow)d+Wp{s9en*K&MO-`iaO4V&TW<#MNEBST`C;UZOxOia+>z)yw|-%W zjT=7(?pQ3HxCF7}4vibY`|e0wow@{}Wpj-i;J=1IXU?yOv1tSP*AVL@MH)?#Shs>` zw#Sn3q9qI^yK7oOv7BQmc6}Fu=@MDeGYSuo)W2#D)nbXM={`mfPP$#Uf@frjsLv@( z4oD-|I74jKKr-`^Eku(MwkeYz>XUA|`t7qaz_xX(Aqpp@Z&;x*vOsoryZ#zu8&(+2 z=2+fdxB$NkwXU%IE(G$jE@my9NU>>!}&7JS6Jhl5>n%;?q+FJ9+wM=i5`U~XF z`RAn7@8?sLK*7Ffw?iZp!~6TPs&z7f0~^BBOH@r+g9v9XS0O|&*P_Ia=3pkEGm&@% z`n)Il;!{Toh(Q^q0jNg^7mUByt|cHRSqs0 z%QORS7>%9^7A*}SH^J}PNYTYtAeL29cs<$fnLiy|!#1csAfg_^l!!~BtJXd`G4lp# z85VHLbSju=g<&_k=ZzjJ<_+G}^Ptf}T#8{jMV39pYTy}WOmKsK_czgjBXWZ_Bho`_ z{M06qP+Cjc)WEaTSfD|SPm7@(m>EH)e^ZpdO#G|@0hhpAKu>#sW*s%#07 z8ci$lU3%hLM*Etos!dg<+7T*sZ@%yQ=<%8fqIm7L@8)MV9zHNu6_SmMvK-fCnO2!* zO$Xg6GWJSYNZ!iy*edAK1QyS1AIg@8>o?q-nCO`jybu<*hXIM}b4afBEZOZOG-FnIHWI&*Y=v0({AduL!EczKPcRE6n17F@;7K5hxCv=Cq)#?-6`Z;X8(*U{4 zReaTya2vV4gkbwfRgSl);Yz*&Q zc7-In!NLH@6qp5(PYjGDw970!qnFipZhR$vj;hHZua_eMJi7~yVOVpiAHe(ECd zAb;BXae!+To4;TdVrh6=K;v^^5OA;AlFXtjcchop+o_o%e6w+Nt6C&0*oa5Ko;T5M1Q&;cC}Mrqj|Ds z2U*?^87~unA90XKA{fEcaTAx=o*4V_FC6cLcF#JXVG}y>f@Y+S8~JIZlVw#df6}5r zZ?`3Q7VXM6$3bARdGM7uc|=)vEALQNNqbXsB9MhXQakQRrDW$pa$pcgf<2hm0;!p} zxM5*9=cvVe4O4cAXLg`BV`$@Vgu|^LfGHxIR5?L&ma6m@HR$W7-&L_%WWqxYsGEnE z5$V!NHKGy-|0EEqtmc!M$whf+LAg=NpI-%LVjhu!aMk6zPY=Z3oX zZk##G|y@;O8V@qVlzpT1F96#Fj$q!i>sznLM;;+=5&Z{+jafZ58%x zev7YJxd1hZ<^3w{L-3~i>v(dodc_XTZ?#mJ>3PtNK>ZwF;f41vAxC-Myp6Gm^|csh z^gsjQm*!$zNlJ6)(jNxhC%>1gtk2`=s1wI3LYl_U8`!;{Ncl*&_=&c9?K@Cr6`uMY zR+yxST&0&6syV!x6W~Jg+7IZ$kIEBx-K9EN<9@`|ya68T4(N^z9;i|)ydCw2*KgSL zFolgPql~kj=YSfUI2mFps z3Vuh&1V2-9Bg;*Fo- z{#5?EA6yY{CI5GH(!%p<|5zu(-^<(1*TLJ{(KY_#mz$@p$mjN|LuEfL$@*#L)rUcZ zBEj_3)C_N(pm@#ct?0#WrcNo`JHEKlc>lWc1w6G@xARBWkE6reEpbl$=3!wljj8wT z>+_k0zhgDcOMIn_aD#G?@6*-&tl-u{o?A0K~%9KA>I8(m+{-s!rVSh|O- zKMni$ezm^sobBJVs((f^9KBqfwRcbz#FqqkdEc9-?3G74x?bIU-GZH7yQ}0)NXBv> zvJM9C6J9iD(0Kgo9O+i*s{x`}YFwnDTbvT{y*oHLN45$Fw^!7qpI))m2*_8=KbS82 zwV2nR#et8{-7UUuJ)OLK9TIl%OlGIw&W_&Xg|JZYrW~^JTn_;kqpGr)T-QN3q|jI+ z0oze)cq>Rybc2CD*v4^NuP#wLUYG(Udu{;H)!H~Q(`?`W9W><{2A!a*?Xo}4GM!9{ zRtg48{?Ol0ybt|9MKs5M7SSw>jO_ny5k0LfZHLW?)bpYKs0daFmnZA!kF)$RHf31P zEC)lwAPLt%voSEHL^O$f`TbtApLH3Q%n`K}L|gH0m8dHED=0^sa9m3`eZj2Mt@J97 zwLTl$qPsFyYo$t_c{I3I1}0F49mPXT%dW+ihmG=Q{pT*`LtYzW?C0nv4Ia>Wt+T9c zhu)aZd{Sg(iqpbk)PYny6wd7(yP}{b`5gsSf;zf%V3N;6(?3B?vI(ijzh8fVQ!64X zw&A#d6MAx$#Vos7$3hh_a50DrkeJezN(IF$U6J+(cMg>%k~f-ZL5fO+*CG*|KxZkm zNK#rq89X16Ryq3FU-3G?F00Llu5rtL({YhPH#U8oJw{v#R9gW_kGP13P_&Ah$V-4; zj$;{$NCqF{5K?ltP^mNw<~|$+>l&1MWsE{zf3&SSovGeiK2xAT5c5 zc?bHEYK@({#WKoVB7nW2c|Sd|czZsRH9*lRV5S*l@EL=wyOneOqXr-`8qbC_5X zi#haBYSiu)Zu2SPIOtlLuPm_rLRx~ew*N-#hab@1n8P2J04_1|oU&3$082^nbXG4D zMiR&F2ULqg&-)`GF!lXorHLelBLZ8h-d6feQm<97VAD&b2YN>+&juRx%-&|RPK742VE2dJ2&KJlrOvmA^Yqw1yM-JP9!TM!%J?ua( z45!?kj#)g{ig9I`Gk7qZZ#c564-(s-UVMU0=6l8i3xQ=49}ysFrS@ zl+6$%%QyhTHV)3bNrElYWZolwJKPcPK3&TGC z#k5KCFln#cML$5M`A10Bp(i}k&>NDa{{_iB@=A1(WJS81vNTNrnTI}LL{o1_#-R%$ z)6o4Fa6@FCxJ9~%()tT9O;b?rqAMiR)cwuS5uR!6Y%wT**G}^(Q{R4h8|~EIBq^Su z7K&9tadK1uGrrg%&LK_a!X?e+e{ASoZA!Xi9*UTX(${M36xFV7~m=zA%t&qpLzo(^%p5?ep`UK$lr9$uDn1||AB;KcA4TY zB|2O)8%Y8 ziNUm^*#a~PR0U-!-18unQ7)6k09y$U5hcT`7m*1Y#D@!kKgCU&QjNgV362#>xJeP` zbpN;+LV`)Wn{*THm8TQKGc8j@W+jS9bnxAQluTs+80M{>qQkC(@gufGRU%IJ>XmHY zAn>*y{tCdi{Y9HS1g_Box2T72IEw*F^x|GAyDz|t$Gd!>=(BJbVD5fgrGpbB%@v7G z*ad_zVHg`;TAR#sHqr`W{625FO9yE0u-KmNcz{>;;HrpNz zPp<`yebR9u$TBQWUmgv5hwA=}n1`XzDsnJ~ew_il55PdsLam+56|J<8N}B5K5w8aF zfP3hBs2;$ugS{xNK@td2RjE;lsZ73~c|r=hE;%-=y;_=*p~} zu$8-#xv;nZ$Rj;&Up})>wq54}e6Xn*9IZ~GwdmuLypX)`4*~UQahOHj4|m`>MmcaM z#}13ZBB!me%PxK_w#lDY*5O-W6OaZ$UikgV?K&M!%WdWp-&-W5;MYUXQxQG`wWSYN zGR6Gykbo)zDJd}-W57XW46sx+LyuAkd7G;Wq?)^h6!ZRe7*@NUqGDJ!J~GV{<{aL ziH~Ob%CVRz7SQQ0?QS+ifdmIpgySYAu0`B;Rir?{4QkM)4TDh%yb~>i8qYjfe$@_K z04UwSc)3BS%xiYy4axBkM0+P`c8R9E)#gw@wU8)rsRBtT!EOn%+JmdOp4%?xCKE?Q zSbQhPq+MZIyL!5*fHcrlCh=?@@@UUtJx4TMp3BzI(;L4U>#xzb{(NxxJ<1eVSslq=Cx+ zqGcilTPnpsT2gP#vAN0kH~)c0{SzaOpeAMw_e6mz#(@U>_c>f0uH)}HWA;bVpgKm+ zUiQl9S@AtlSNGNzS=DR%7~r0jZOcM}wTKep10gE_HAdd#M1NvG#8kvkx0&aR$PUAn zoD3Fh2+Sbx=KZ#%88)?1vagsnD?o>sLsVLJw_;qM0>a)Wuj(+b$Kq+AElsbZrY?9q zN#{Ua?ofeEOTj~7SnlWNr=7{j^%?Q2a;Y1swyoGOaNTp*N|P;l+N_Fkh_YB}d{mkL zK+5u?+NXa$z5S~ZJxHv0dhd5lv-(Ed?8wp;q@n)xK6tZ}_mA_Wac5TB?*o)SJj1!+ z$)FkEoX)%ma|!(%zF}!n>pJ`z4%hOc*5Vr?HIoJ5e_W7 ztyJLPJQ5Rr+K$Vw>#=V=%4CVRxU7BmC%f9?Z*g^}m#V4+aR8uw)?zFD^S(fD)|Z9% zYl~h-w2L0@JZM7Q`G&+^JZ%)nsXh8^4|=@?^y~esVS^{BUX~suwBZFXV3?8MN8gQq zKW!fx)|@@@#^%3mjG>+*T|Wf--x}}}=vxnGx$~;%&(1J4ZLsYXUb$cO^F28swp4*N zU{IfgQ)vO;ux}8pX!Ol{)1|i@Wl|%)+9YnYlo|WQ6>gWJ<1=-6ukLqMFO?y*bL|&_ z`pboQTaXL0dqLw8(#k0a{tNeJyI+l+8d{<0$I`*V@$TJ44RW9%yk1kMOCfeAUK{$d zlbo5GT*saCytnDsi2nU>KfLKQkQ>gmy6@`K;KUzp_wjxCtkF+n#0=9Q;v>2%g_{wd z;Yo=dYOeekcXluN@;;NAnvoZZ{HiPH+GuM$*p&K?w@7d?cBjld4?I_p7zkJ zCF>C4>n#^6nC-QsYo0hQX|7Ho=u4bagJ$1@O{c3PeLbUJMY8p6C4 zQZH~%PaV|M+b?+ba1>4RKzMNWZQBDjSdpV9tNhXhB3su^8vHIk6aJb*1!1Ankve_^ zuZbO>J_>m(4Z!d1{5R_Ycvw5e79%NlFV{0eK}OsV0YPq)FruM4ESsh67dMtsGCS1@<3wton8TUjgoKX(J&RnJ-R}JS>hGOSoMc7p8;!jJrB@&MNaeL*j@#8Lp=48sqdDP)_`_{c<*j4*>Cqf4;Tl! zUl&9i2%%gHQ1J!?F2drXj{3V>y*PVMW9NZuC))ck*$Edg@9%9`g?zjPRYI{PA&2zs zJ^^FWqH0Bgw?M9hp}%8(k$qfZQDKVp0;h;M;yj%{;+~3%9lK&b*4kCIa%E+fFeIkly34!2;s6fJUcuBJZ?*ThI{M>_SG($2 z3AQ!QN>|?@9FBHVCX0EZe_gr;rGOyTRn8SLQRR*zP=p??SWaJ=!JIGz*9@oHHHsfA zJ#_}YHNCtGDNLHH(`f|`?!oh%Ht)$CKjie0*LXiCmSx1et!OO&n>24CXeLAWvl}3M zifdM}iA1c%BZ;p1Jf!$Jj9Dm4Eysry<|d~xzYusm)f&|}f>S*-&ye5GRQQinZB?E0 znE!Ohg8TPgyH7@!fEbHF`jt`E4>GrBMrGFA%J$O5RTmwptX!Lv z4b}gel-7x-R@smbiwx|2i!A#Liu|GN&T~?=6n>6wFTCdpf*)P?>4fhtz|_v;!_%O*I)bnZf8rcDCEggj9&K=F3Ii5Ww*G6&!ynLs4Xl92Gd2D#t8W6syN7Bc` z3M1wUgc=bSXeb9F`nhS?G+bRmW=h(`Fmh(@9T(qwmXrd&4WA=lpgELvd?m$TuqPgZ(KE%N_dmP(IMtjaU##+WSmg0b!Ig<{hZp+W~D);Sse>!v3l`1RIO zF@LlHTk*#l6g5I&kJKyl#m^TQ@=-joD3y3kA!ADvJH?7vzdz17k!XGl8+E-dc8qQ! zH*Wl1_w6*hPWHf(u4{rqUP)hv@3u+N!O}{d=MRrH4c}^< z=~tVlywLfzLhogdXNRE9P*S=OLR)$q<3}57cfNW_1z(4?=k_sInJKz7h2j6Gf2Niu zK)SOw!}y6*8;n|JIJn@2W-p^ve4Pi|VQ+8=h=}9iR*ECO!**hbJO=^M7YME1-w)oD zIeOeD-t&O~Gn|T(2kJJtHhqqsu1@l(>d`f{wXWsy`MFqchkx258qR*NN_KK<58bqX z(Xhky=f@!$a`08&?{H69+kN8$$`|4PJIKKPAMOD$a{hB}`#%kaUd+<(tB6L9Vv)46cKokOIvXbGRe`|14daIlZ10Rw<3F z2?{NH;(m}OF)=k7Go4mlar?s`&8(46s}(d?)@*A-l^zr3hov zp+Hg;gRdWV9Wq+l?%+|B>JQaB$vtknw`}`SSkR!1nb2e0d4Y)j5GXo^L;8bCA<98IR|K~%8N*2AX#Qa1d?U=uxw8f%M8Gz z7fZqwE1Yj}_XYB_>7z6(%E}Whm}pev}Hv%9UhZ%9TKMK*)H$Rh(W-IG|+xJANIZ`Ap=;Kv=$!*)u-)@3_Zz zq1@giJbOuaz0{QS)8z#jlRF#-s}dfB0e>||52=K*SBAk9PbQG2y>J>hc)$W%PR?X^KBj<8Ux=L0nC)=uO;zA;zCwX*R%(2Q zSeLkZ1BrfleavV1+_O(z66_Pm{0xlq|GBjyI|PUK%az2)?}xd9lSS9vHJNbg%h)si z=W{M~IskA6$4ew!Rgcz}kX%Sg)7=3BUGrRlXxuVG>%DC=teV`4EAetZLpwJiMkU*! zg?E;lcb_JEWC^KP{-ZLdGDq^2S6t9Q>=>Gr zk{5SB9{R0dHKPE6Z&DjM^dmCnp7)zqKX8GHq3>X>AfcSOPZ;BG%pU#}lOxC&KKC3# zqm!_CVgBIYT#--3cN>4&@BPJa3&$pNFNhOiS7`*jmSBt%K>kZZDu-|Kd*XNuX!IbTYhbMC zKQie)_tV1;e$aVAEbBC@Uf$@4EvAmzIx3^wbu9iNWpj|^!0;BO(nmJxcj1gRe`67N zCcQM~ud5kAzrnL-7`OZ?5ZRJJaiB1d71klD?Jpc=%Iw@UTVbZ`nusj4?}k;>mqy;< zus7dc{g-SMTXmcD6{o+w*CWVJ+@}~so3@ntX!MqnzaTQ5k;&|`H|upyY_(O`kKE?H zp?ZSlhB$@;yB?WqDVtBnAg|@ZIg0hbjvW@MsC`L>`--$~vd7H9W9k&o&h(`Byp{C! zRVJd-Lbc3@Z2q#a;5eM@Pu#QSTq3DeNC-)w>d*WdX$k~WUA$_O>{&mh#`PO0gth}Z zV6y%S6!@yGwzr=IXV7BtXpg$~lLb?WF! zw(@M0%E|)%{nQ70cmK@M{O2bm4FR`pZy}osZXe*loYmki3>!uT)c1;k)}$D$KR1{X zmUg@W^J*VlI}8C}D&Ek(W5%zH3@Q5F7ghKI{-bf&JzNd`QlzELj~-rF4@Xh3(wFwO z;pN_a$MD1P7${J<9s=#(A^-S%j|!^LZD86< zH$m;P+4`9(^^aM$xuGXALl%#|bmQP4f zJ^X!-K8(Sm7h<~pdo-PJhgi0{X6I%)VdfVYnL(`G+tWT{$jxTYHdtq=dFo!usH`C5 zlGewECF0AH;@KZ?6D04rWkTwS2_|A0LMD;WSK+1W z^Y)5u0vG@i+T)I?s(ZfQ)5$UK@mzCv+2OOD8`}>g5d~uPv`}ow$Gal2qNzS{IIkdQ z5jD-c+p$5YG_S^Dyq^sB16%Ajswqzo=Vin>0+IAG3*#~tu8D(fWt0o=hR<^u9zdgU zHgU7cr${+Xj%hR;@o>%l);)0m^(WjeFt@Vjbq&^a`IL$*<#TAQzUdwolk#vWCfmY9?1ty=M(QpH{PLsX0JyJU=EDtFNXF+ z(SfC&#&mlaJ~=G^q@h3fGYZ!a6YIYa1OWt~0`?u>4v^OYaNq6Z_x?b(JsCUyhwc79 z5c61>|DPub!T*1|4^@%1-(rC4eN{iF0ByE@SMF@HhJfRR3%1`v$g3p*q2WwEF1xA6 zx16Ho0$V3d$-~2cr{Lt|Zp!iPoHXvava@?toe@b*RaI`d9VnT|Qfg|eXzoI*!P!96 zBdS0;MP`9<50gem9yCT^^eqx?^IG~gY#Wue}RI+5Mum?qePgy(mncDtm5Y-RR)(69+AFKNWU)% z^5dG94onVL?Kr@TZ7(sLQ@sO8YiYPLp0Bw4F-2C|eDWuv=n=;5B7T)Gj9J>qdUNSo zV878gMz_0-&ivh7u+d60eU6XgR*^U~Fd=9T?+2Qnb9--zF8 zp=KzZgvtUo$64|!I1!?50rK`kaMjB8rDcsmg;T~@n9&!2YNLzf{pr-l! zq_t78sZRTYz>6F+{sOUzKnoAq&Nx%-bj?*VT@*-W*Z2J#XVIqW>5$!~%AUI@6BAwd zcYCU+bmmn6(R|538=zxfO>18&3#o;DKR}*y5ZQ!jkRHQU@lUqXG>078^4;P5vdTYN zIyqEbX_QGikRd)fXNK^Ibmlc%B;wr5Uu0N=4GyM6*2VSd2fg3Lg`}{1r*I3yR+H8f z%3UN)gG&fJzN5CySTd)zJsTXf1(9VXz{~bs=0`+_;|7C6aon_Hp-EjoaM zy_Og_%KQV*n+e1R{h4_gF&+UngbD{u-0U&li$4(N954DJ8hm5zrVRhpPaBEGyyx(R ztdUbBV+BdEVM%Jhh`+$C-ViE~jVFlo0j%1Le4xMr$g@EWF`h?Q01}RM>wAkq8<3E0LwfTWi-DyTTu7@$HS$3nU|jIYbhuaRE9&bDV6A#D6@*D0R#e zf)fb}o(42C1YcOiUtC=Dh181htwwW(!hiVd^lVduYTHDKZBrjK+^&fuHHxW1?yFIx zT%crID%OQd?g>|J+F4X2DDpWb6NIRIP^7djf+oK)iAXM0&lW79^m-PE`S%|Z-I<8Z ze+)QPpt#O$XJOJtIYwG5Iihc294F*s^h8fK{!m}zrcnFKgw#cjL^gxcPKg4)A}5u- z;~W9tc)~Rj$E-lkrS%V!pCW+@CPE#v&xAk`8`P(!&>zHW=6<*~v|W%|dbgmpfIu)6V@}e{>ifhtFv|Jf{yPW6aJ{TQkM5mjwiN-X3CJFl ztP!YU`FHh3(@80v)F=qSpRj88K(GeGEcjLmJ!51iVRUn{*KLq-U|827ir*M~0s=Lr zN@9@u&Vq9w`0{Ux!{YJybxyjJh6G=5OyPMKV5pRGgjV+^4Ad=1jSp(xUNv2pHAYm3 zb;r)8<`WeTBkubk~_Ze@o`Iu#Z+ntMbe8Jrx5*9Ht_r5-}tFdnzbu>^! zAem&hhQ9w=(nqP(aiF*Z}If`{)gQnnq%di~hWAnH2lY|Az{h-xXXGi`)b#E^bWFiP)>6l75oQ)tmDci2nrjHbUA(+$ zFT&qIQ#PKa;-5M+L-hQ$wAwdw_wap@12mwcg~6pd>q$tmHKDxT1i{c2*#)NKceqaH z!V9)INTI7ag@$>LlrkL#A$j_m^jhM-L@a@!BRGne&f|^szge8_k5r3^eb5v6xQEGl zT%$jK=3|6MUkU_nl1Qks663cyMZx)irJ&G$0mhNcC>Ca&04w93zR(qxo`b{Y9z4(G z?Qjf37y}n&1MLmwUP!`|GE`81>4(MlU9IL8WAE*YJn`PWqcAA0BF>L!X)$I{t>iMB z%Uh4ugCw_cHW`SLsPr&-ylE=B{R#pfAz6?5OrNBQkm@qM^10m`<`nVtp zl70A&((5`rH7}f850%2*?v7N&)mdZh6g056^LSMiYB}rgKP`XahJpAKFe0G7W_A9~ zE;1oX_q{I;B^kwq2D6ANtfuZ_7Ip^Pr015Q@QZa#P||=OZSm?gt`gM? ziHsJ`@ILSYDy5GrR5vZ5D2zM{a^~{?3-Q5~(dPq}xaSj~;7V*;W|5xNj9rh#hD>&G%XKxua4M&G))<~G9A;S2M_H?Zg?E3gdlZ5G)JYYnjpeO*r zv-olSgH5#zw&>Np{s%l%t~~p{AAC3%|2t=gmEnJWzP44Cjn8I4>OE6`vnUY)7A9EJ zwXIgOS^;fugM`FwNQ!tYi!BMWk1b>aIed9oo$T ztdK@>jsp@3C6MS$FwtR!Q4e)@#keYmb@A*JjmEG~@*?95{7XdDM?r6knQ-|}mv08- zFhQ@@3aO&bFH-w3s1HT#E}~I>5`{8#XB?P6kx<(Ow5DQ_1?(Zz#a-Tu$5`9x>gCbT z0}n?;((fUiuGIpkV8RmgJIKGb$4)W5I-$5gB)FrrIh9||UvUb=IE&F{_Cocdp-0nG zSASx*hEaNg6Gx6>H-YLvUwJLhaz|CVWzH0Pg`DX>;xx3tFHuzsP*~fYl=huf)%Ka+ zT!IYw1TE<~Lcr3%zLU*HtMRd&n%OOc+!gV?WGHmNK-&KC!H?R~v;H0?J6&TG?=T?0 z6^$nr3HIH6a?Sj9RC{e6172_)-~#*{pn*N*4!?&`ym89FUXnrMJlp$yj%p&*SgJL5 z&|H#8gZirN6y*Jz%;$adyZ;bK|G_QOq?>DPD(!YJ)@Z4IA|m-+OVD5R?L7P~!}>`xG3vk`?mQKhfG&6_sPkp$&L z^c+@l62P<}LZs;`X#rWpT>G0jG0bhO%6~U~dQ|P(U{qVEJdk0qh;Sx~PAqPhr%3&xKNY%BlGzU^`b-043R^&a z(IsvZ5%FQu-70-5|C}5|a4ylsazOYVlKU(^2@{l8gwT)FQ7ctRb;cf%yRSk~LFtoV1s1)DQ?xpX_2 z1Gsm&?P}<6)s|-khz}-n{9jlfojBf4-OXp~0$aB)fAAI0WT{xf8f)PKcxRXJQ)A2DGUVmMpiI9JTUY!rgr8o7K{W; z%#57>HDV%QoXousQ14Y=5u~@Z#^;^Clz>WIxd@xhnE^zKd#!ts ziIw32RP;!sH7x@~My3WqMuzU;7D1V5y1r-t1HOFXsn)4 z*b~evFgAleFb!jHx^H-TY-j}1z`*DT7@r@^gd{M#wljrDFbA68SO?YJpA`L#+nZBM zL!&F``SXM<@Q+hqaC&-L@|n&pu#RwUV`^oCn85DV3bq-@l!d(oqVij&HlR)qfEpAv zx45#B7@oK=JRCf@J{vkXxFHmfg|KgUVg;=L+y#`o6KEFDPXYQX<|Y78HU=b*pwQgn z^sZfaX>faKcnt>@0M@2fCg6>c5S`tNHID@}g`kj{21>yNasyyX``ijZxW79E%D~D1 z;N0%*`hzz$0n(crD=UL@iyM2>Q+vS&wx`gc6jBn59bQ~YK{2TN~f)8{R$Po7kD!oBd$GGqa0}xq4HRvlq0i_uC2(z40@_7ElM| zMn*;^2g3rnfB^Bz(qaLm3QkX;zS5K4=@}z}^W%$yi3e~+K+nxh5x~9!UmY3UAVG9; zcLMzQ04iVfLFQ%<8Jd}0ATj~yYJczji-Jc4p86TjzjAANfV*T09*iLvzF(g9WR&Msi&kWsuq5;p8%*tMR0k5`JS(FfxOV&$bgucA#nmwp9k;!k0`LT zzq{l7-=wy(xq&(WbQsI!fRyW>JFJ3_*B}MZANI5$Pz$F(pep|0y77@&6PSfCCYoK{B{IgaNKZIM;z=hWsOc#BhPc68R%g2Pi%u9f2`Ne+ca6 z2fi^JnSe1#e+bNgijVO}Knzkof;E6+7X6VZ^0)E9rV8#M1DPm(FdY9qzXc02sQ!H@ zyTl)XFi`mn7QkZpAwVLY;fG3*zv_>`NfA6l1kuC>2ogvq^FxiyjclwhLqK`4P3r*6Cm5(||YAfNzY;|nxM zPACSO20p+(7a7g7{g{zPG*>NpHAHckTeP4GS1VLWS-v9Owy_(u!H`isqm1wO7cK8E`51!2PI z2k!51zBOJkdJ2=co_Uh1Jao`4)V#nn@E@h*Q` zOFge%rP$HZh5zdzPlLgObCtKepf>=2srap9I>&9z|{B_IJoNfp4WI? zSU0bFLwU{4FLu~_BOW?&!=0 zo_>c^!*q?Yp?qDScb;&gh|jADtNFgsx;M{k9v{d&oen8vdNL{4@kw-kz38s~jkv3} zRiiz_FquNE*N1WIxlX2@#-NIJ#phawU+t2 z(4t5$&NoYO7!a`7XX<`~(KM6}vTf`(!IRD!-*rztyelJF`oUH|CorG338)9%xHfI8 zA$+kVM(-Hk=<&+_b}PJ7Ix7)++J0FR?G3xMW>2C(t*{)FY4YhuOz%3PM z$Q5?T7~#6!)V(6(xoAP4)eA%;igJv9Pd5T!Q=R)(3~p z!*!-i$MDTFH+}uN9G1FN^mEH32jAr)L}j#i;*U*i;+!&1u~1fxInrk@t$MR^T(!G+ zGwt*FjFhI53}fn$BCgkDQX9nY6{e+~$IB{3zD(m%?}&TK`kg{57WHhn(x z&SX&crt*pOmZs#EP-PcYf)`{Q+MEZ~v6&Lc(b1L#R|(yW?PaoZ95@#rySy-d{#nd9 zqKA{quLhDZnvEA_)GdeYzAZ9MNFe++WVr-#pyH4Xw|w*bm=5OWt}iyhqg27&5-rGg zD{V9Nlz*8&rv(sG1UYOldr-fVKu{H?ao#cYQ?xZryDLxfgO3;*~NS3rJvf1ZZ@Zei6j>8yyrJWlF?OYkGY>sE818frivuk^TgM++fcwt~3QX@wx? zs4}F8)Iiw1mCHpj%&Tvau~DA9hSJzv5%jaG3)>W!JNb|Vg-iT9Itl`Be7c+3=0s%)(p;M?i}*Wo;GbsQ8SCUs8~xj#TLe`tN+y!fcm8Tc zbYI#I!Hl*c`oQ&dQ|-50L9PWC8!-z{G-qkuBl0TJR?_rFy4kRctAtl_@=KBN zR%pUwR+4TR)_%){2jdAHRa7Cf&gd+c;=j{B=bJAnp7@#<_K{{x@?2V`R}-j9c!3wS zG-N6k+EI<%`B}XX4z~F&MuVJh!Kpf14wUl;>FdDg-#^LoaqR)K{DlL#wfuX-b5{|7 zn3`Yr{^A$6jKbf0@`GeK%XR>hWA)GdNJ}D}zWRF?Q#rIxr774B{0_7Ig*D4-{=Eo} zan0X8_x%({XwT@29g}Yth`9?pSTnB3_lbt96mL9IY449!wj5fW+iaP(5HNKJ)Oo}y z7r{UQcMBo2v>_QFSwXy(^g}UCF}5yZU#CF%9*L6`tA<{^T^S2PB=>@vbT9T>hGlJGKPU3Hw>cmO3|?* zx|gmHHJYF}V=_~)8=yluxj&PI?K(CPuuH_;6gx{soHO|`{?5)sx9DwuW#0c0uT2Wn z&ym=%u@|`O*XhQWbX+(BALPhE~2C-)*|bWA={gp$htlf?UCi za=UBj+GuSHG3DI<_RCDeO2~-3mWy_hQ~BeyiA{P6e?ld`>EwN+V$@aLSH zDi#6arshP7<+#4ot&@;8PYR_pvo%Oe-EtEXBfOgP|d$R$~Xn(2b7@73awlj96x$w0ZiW*r*0Cx+1Y+g#rAwk`jN7g!&Q zymBd#Sx7^xbrKvhD)aMtiZXjd&C&p-3!!e+=w%swdsT}F#)`4(%=gbjxX=tm56ZdimYqs=u$qhsm@{KWzGPuJ;Uh`r|s>qKJrv&T830{2Y%xJ}Kn_y^s``#W_cm z$me8zt%}xs-?bhx`t7gR)CC%9o35P=76UU_=fTFf1yj~7@}`bDsbtU(4aUO({rS^Y ze;gXpd4Q5e+2g0wemFz^h(mILrD~w54hL$~9O5mq646`bVKG3X41q+ObpNa8LI~JZ zXCT=f)DyFBgr8_Bg;D*|qA4hi!7fH;XO*xuy$EwJO==blW8@*ml+OJG zKh}G~B=1cnu!Hmg`fatsyw7Nj+k1OSmQ(wrhV#~or5o_+RcKDoe^qN+QUptgq83hn z`tdp%EHt8J&MKIscCGg~G5*evpo<|sgY0|W1LvtHe$!cp!wxw44R&9+JR#dWx>p0k zEdgD)D@J1$PK>9u(mKzeMg!_eV_q-a^b#Or7Zs=rVsS}Ajnmpo7g;U=5cwnE_(4}5 zEKfByXDZ&rfirNP~r>Oe9>z-GRQOnO5w$uJiOJm&!{9w0C8HxPFcnr`z7*BRa zF5~Sj2{*b}G6Kgi^OojJND@6Yq!>Z|e+VJv)4l?i;w*PW#ev=8YULOUwKQi#oRZ@3 zl^;}Ft+tD#?b}=LNU6SEd_O>INil}aWeyLL#0Ep$+4w0o0~-&vdg?LEii}}BdtS>! zlD>6Y!2?72AzdUwaZnwfrm*SE6awWAZ9yoIcBq_A90u(Jo1}$I`u-SYsa`BJx5r4q zz|TV{Q`WG^G`V{Vj(^u%^J`apn-Nx<#+}egm`$wbch}8oWk?Qw;%-taZD~0)lti}3G^gODeGzMC0E3S=jI9lNLx_Uf z)N2gmf;CSruYyI5Qjci__!*OcLe{To1aC)S!Pv#jv`lcX4-djTe%bNy#pf#d;S3%_ zPpq(87fO-t$+Nw#1KWV3*qa~F`LSr#^QW0a*Gezi%lv);{aWgL^9ph6fA%xArE9R; zGN1gwmB|B{ovCDSlsvrwj26_h!w3z?-G=83(Y*$%A6p93>%C#oU=DaBVtXY?e6zP= z2JgRttb@3ltHp9=Pw`5>i*C25X>Vbo)Id@aMioY}^VQ5|;IuCNO+(zrI>LKLNLz7I zf3aacQh>IGm9;S;SU}Cnf_3{_gU=S}Ls)AMh;HKB%Mk`-ysNYTf;=Jml}}&MWio%F zq!^8ISL!@98NUv&mUhEYt9<)>XtxLdSzv35izq9N+e*|Zts@5;7@9IYxceqZ<-|u) zmK29PP_@*SU2dU)Sy^rEt86Tb%=C|%!cVJB;&@Bc?Wq)FnLtiCQ}}S^@_A27_Z`xj z@|Y*vT8hX~AG^}_Zfwpta5SDvhC|wvj<(bX#=7UDC5b>`H7mUipAiL6JK#+^up#+o zY?+BPmNch980)l@BkWVE#KOZGd{fsZOsh?7jq&picYVCbB#-TxS%jzc?%u-hp< zJMQDcqKDniA>BJcB8VQc*784nmsaAKMryX!k@55u69-IE@?RH!@;v*w<^qv1@9$;* zEEk8?+ESbNm-rO6i9Cbub9uAhj4?OlV4Zo2JObgA8F5DW>N zjt?CGGjq{o%c|+dDN_IQ6x45u_-4sM1X#h+7f#ro4iiLqUOF1lcCG9#w9DWoY8a??hemyGSAPTR~8NTDy>GZv9T>Q&SaRD zfTMHK=GJJ>%)N{C+PA+)#$uPJOhu0PYjz}j|Ee+Sb^p#GRrt^aXfd)-GPUuCwr5-a0a*3SqPOWCo_iFaAE1nSB(G(EQ-{- zZ=-C;N!f5am4x~gi$FXLx@F2^2&rbzY-nonX$STq;nsU45IQMvpW^~WXr>nsG4Tg$ zwKE?IFv8a?s3lq_mTohZU!6acfNpePTMB7a(I&E>JfcyRJG}5rwh5IF zE>8BwLfMZ`*HiAIm+2<_6r*3|%A{`|s|?1{MX}YHTU~4P2>HcFSwlrK?1*-2eW*hF z5MwW==FMjv-yUoT@4~rG*CDJq@%kMD1-%3Ksp`(_ey(QpED4bRz#&BP(sWo{)ESP{ zg}|*nU&XIA8lvZK-5TjCtFW9VVAcq7I6M5)W@l^o_55Xo_`9;`~s6;kd zGo2T4Lp&P91rC;{mi+#AK7kCHXSMbE&_(o~mfhO%jh`p64H;1w1WiGhlZoB9NWMo%^SC&(1O+Gy}FOS}g^?jHO+6N*{3 zy6NZRL+Nfm%DhJC#?4R+UZU^t*FiBGL3@I#Xt6kM&{T{FzulSsq$wQS)Ci7>vk&8n zbs}x`i6F+RB+VUUHAzK>7)U-p3v^$8`uGYr)B4*xY-JQ!}cc8Y*200C6bP{ zZOm^2&)9>HAMOcKPm9o^MHp@IIQ{m%8O+h^d{pIr=Zh~od(KyynHQLT*&;YB2Kf0_ z=(f8n;vv5v$&WZSq|2h6Bc_MOEH7LKBZ775P{InxQe^GDlYRw*m0I}lOMgFsIua?W zqtJ_(oO4R{J5mD+@BnQgvzIg;{5D_Kf3B(AFIQI(LUQmhXev%*G&jSM3h&REM&&cH ze*I-FYA&kyTxs|5^*@_?DtEah1Xzz{iHA!ub)mzZ-xdsg`Xa&XE@=S{)5=kOsc^M% z^ICrk2?yMj^NdWsIap4`TC2?z-`~tPD1MS(%u3Yv3Y>*v*RhIK4bi9Ae=j+45;55q zj5tL)yW@+^^qL4|VTU-cAnZOu9?COqP{81_K+~sl`)b>%YDKAbb>Y8^E=ZY;nc76j zyz}gHUQJni`}Q5?)jgLBWW&UAOomeCHgCV0+xUd9oV)vbisi~pdY_==kKxbONvS={ zrhxdfUA3Md&@jGF1~o99p0!zzV9W2s+%5YVGYPM~Gl%cFf0!GkBYsM`0eIV}1sD}qTJ{BdsIU}svtz8LKxKaXZ!nWvRo zRS!DaF0Go2mM5xIZ)>p=H-`38v5a;&il}}UP2GfPf-ObGj(;pN+bu&Ztc!s#&L^;q z?(BCg8E(^Zcr$j%a0N?*WcK)j-CNFe>_yVp2UuQN*>SXrVm_d`yFeF2wRbjDSIU5P zOON%qTVz7(>^N-P&6@%FiK=u{XR|6J`eACsl!eM2UWx3s-I(xK6~!E-c)2J}+X@?G z@GqaZBgbi-c&%JLRml#dAli7>D&kByp_EOt{Yp>xHob_;drV~9$?HTS{LFT};U&bo zal>|-(&iOv(+-Bcy&3%U;uiSuZO->#s0caMLz6xJg1;UVSA8?(QQ>6Al7hXBCZPaa z0Xy6!;D%0A81@YWZFN&LUzkHLAoXQ_c<3Po{BJE4hZ4~jER4)zlyu)ODwOEPscjPd z4J4mP1o8|bxHGEhXc{!rMQoWgIB9N#CFHpSozu}U^TFm;PrM+TV1F;JAJ-tvnquqT zDLNWsWcmm!@FH1ffxTioOV`n|4Tv(qQBxlw$$y^rRKP?jpEPpp5itWq$PjKD@Yc(J zVRTI{LPcUH>X=;28$Z@AiTA#n?IEOh#l_*wc&1m7iBQ=eg|DZQ<1Dr#Nin{5IhUyI zFhXYy(TQgfG|N9f!&q>2W%Ad4ZI^avrXJj=%<|$%9auDE>kvS z)OJR?a}1VpC|gak!hy7RH$E!ZN|DH8?gt#riUd?N%`Jbpbb9eT85(j3h_RHhgrxnk zgSB}z$S`@v(L{WM%LYXh(v2ulrc{aPNj^+Ou>9kXd2czyXk=3zzQy$=PF$@5$no{b z>K&%qMzd!U2mM&859uWR*tQH!Y#Klc{`3m-6t*>P52GDvDxlZt5|F>0$&3^cq@tp$xm)yNlT$By(uGg zK#FJ(ibwjS+gaZZWN0yp7xbvy8Jf(M_-|~Lv~w{h{Xoxiw{#oS*Ye|!Jnw~;_{K)S z{w|Rg@o3{2nO%kAx4Gelvksj5wGU3)k@jxHPQ4#yFB`Iz|H_p9=k6e*VREewkI^rh zD6x4Vrupy6U{Su$N3l6@KSeIzE2*6q&uCf}8#$%4nqXOer~BD4`v=Bf%+s}!atI$5 zV_n_`&%Y9=UpcL7!6CEfl*8bcFh6xsPAHM6GR_A+Tq!mKx z5Cm%k#Y!1-aWzG3%{UqPhdV5hwwq?~mHIKeX$i@e9*PGkWt)O;)XFO1%Y%Pk=h7Gv zqTx|_H|*X*e<8Rju0bVsD?+R(FP49y%6)LzSl5Jk?U&d61=FIjZN>BJ2`&1_$jr~2 z5an{Abhp8lzIIZ{rW|Tr1`quv?zER6;q{b1D)gOmx=KRL(+C@JD9lWA_ zW+tMI*e@(lIq37n*Ohs}_F8Jx-Y}`Nyg%GZ^@-kf*uL}KgPPqoCsd}QsvoCezc|r$ zEX~RwHHw(TqQw8;lI_ZV#h8B5bi`tW%0+qzg`r0eEz28mB01!(onjr4`;~^I>twYa z<6)UFd(bDDM}Rfe zFY%IMFkhd8>}(i~O6KPXPcrQi-1@0o&G6(k*ET|7huP`Enm*E9unhFo@d|o-u_c8) zX%z;kH+Z6#7tUDTDWf}}BF?jp$m8g_p3RJ~C0*{99+?$jwBcaZ{8;mtsx>+4GJ0i@ zB5+cpdH1s#iKe)M#+_FG)J}3P*sXTKWKD0&Ij2O?eqtR;42;;QKfNT*Y$>V_OoXQT zPe=JKu+?Iww{fZV+QC)$V6^kS^-&L%+ZIS-h+_;&uysMFf zQseLDwNNGRvor@c<#A*dezY(2T9(5Y%ThZI!ab6?k23A`&k7S>Uz0__1l!X5CS-s2 zIm;Zp@ZxEu;}r8}A@~HTUw>%2)`uzUC^7li0TvkMhSqM@MZFJ6hh|;BWzi^N)ZOYO z!@uRaX;$u~M;dz%oFZ7uQZX#f6|qfj@hF+Fcy3WzapsCl5hltfuNT64qw}M_g&vD3 zX(MFx{ug8C6eCKot>Lk)J+^Jzwr$&cY}>YN+qP}np0i(Wa&K}TZas7=_1K+CrB?sz z`|6@R>$ngJ0pkWEm!eoFreg81#|S#iEOm2V9^P#Xylp2khXc=+OLYowBS{E52+@Go zB{5Lb5+pJZPPeklJ~W-xc<8{r@BaPufciyaDmDL}{aFwVOsv7mAM6bwXz^a%$eh1Y z?o37tf-gw$N?qZGudz89{Ukc_@Rh8peybRlkB8B&c)6)idf8gJBSDI{iS;-v2edQy!i|PWv zV^)=1j0J}h+;R<#xe&pkK!0{{8&`QPXa@^#zX*q!F(?VkH@0!H^hHLwQ%B{R?U zjW;RQjEwltUL-YQWO>0vjdTvJVM=0Q+*gDCttWV?A1_`$dm%<@YF<6mU)5f=V0fjf z=96Fqn7X0Eh>Rn_ZsJwwmop>0*pLxIu`a)TP^RkC&e)vWq#)X$5PP>_ox)5gS854e znSQQhj2!%T$SfdkKV<1*c3g*CM~6FhBZ|e-*D58+aohno6-t~|ZC|TnPes#6P(4Q)}#c2yDp@AQD}Ix zr%vMajzK#Pte+yP=z`rwAT0)c{_VSFd{U&rYftn`C&)3|==0R$T)k8&TC}xW9Ugp7 zE{luWa0I6%UvWK++JpMikm7&9w5-!k*{b9XOR`0!F6e^mA$d0Llc?U!!)o7F=^!qHb{Cr?~O}SO#V$w5hnl}A8n5oir zYyH}ON(d&cC^HXE$ip!`P=Q#OmAll9z+g|)KWqdQ`Td<7sijDJLr=dLkIOcWaN+QCS^S3_H(7r>wdtU6C*ZY9+kdZw9 z&>N46WN@Viu-YM+%=Gok3rKhx8`xSC{3+pCRjL2ny?9PLgL7QK;KP8&(xL5iy2BRu z1<@-SNx#K)6oTujW`MwX3w2so(cp0lvzg%PJoT(nPEIBQlZhwb&vACIksoKz5Itnd zETp8m-U=S@xw|Xv_&`h+uoVkF^9kGpk#U9Mzz;#dOP_xaG8&5stVs{7jKr={719u7 z9MY;B7p_^7Kbglb-$LtInp2L`#f`I$+2jbtMGk_*(0-u_uOWQmKR`q*1Mp>!ss+E@ zIHQG1?|_$emB6ms44N(SBj;2mzw?M1wc2PH{+XNZ0 zw5g9c-Kfm+#Zj%2{UohxUm5Ntz^}fa!qE7DaL-fo%G*WuST}Mlh}7W7=7CLtO~c*C zzmK-Lf~w11wD^g0-oN2JrAh1aYVAw7{Sai~?&@T4iX#B%>&_MYY?{zR#iO4*Zh1`{ zBmbtCI#F3IEZ>tkW$+c^Er-(jnD2fS3x23$_sXzoR|^NJ%$P~z@wwikZ#nOT)$3*X znzM`Y(8=A==tD@+OZ$cegC#+7QJaAdXfAs=4%KZSc`nZb3w#E8xaHrgE8RvxU92T? zSsO`gs?oS7H;Lw?nAojyf6)Qsk9xjM+Z&ReK87?TA5BBFus-$>f7oCjolb5%Xrew3 zsPaHh!9LkG#e>NN!)?J~iBv1Pe*Key9{FfdxAcuq;9ihPNgs`KUZ=*DEKz&Oq|woN zJ3HiHxl8I;7zA>5>@qE4r1jEg0}4ZBLM&Yq(}z9dqe!ex;;A;~PWUZ9PdoXG&+h5y z;w9&XC742!Oyp4OJBEsE@yr7oVEnIG#EY45aQOf@YL~tc93cL4gT%rPqR+BQpsH1_ zfbXPlR%VZ6(33l2ZivrN>&n3~uB60v6LGHkkHwj8brI<~z;v=z`ZHd;gWT(cRCJcB-k z;;U@Sn4l{e{uZYOtNbd3Dx(9#K}CJ*cfS(EWidMJPxO{%%a6n0pM*(i=iITj3c8t} zse`pTD_;xRt=Lie0zJXCY$1su-;Ui5dvM}A-nN1DP5O9$ztK-QF{>zz9 zN~Jj~;I__?-`uM%yQv}_SAL=`sutqtM&61(!2p%Xy?iXQBbs*Dg!*T_a~3Wp#*~*P z7-`3vRo%eIzl>@1-*5pmN$zDZ= z@HXvGtan;3+M90>-RKgODaN&-G#WkO7X(012cJ zs1;{SJ5;li%G7T77t5$t!G2CykrNJrp?Vg#$Zo%iNMm6E`dw*eF>#FsEaHN1&F3d` z>D=ug1dD#{6PMUOTk}LZ@CPVT)J{aivj$0X-MD-Fb?V{;SLwL{6V3|#?O}`Epr|lN zGx22ad4fqTF(d37r5(Oj-98FMEvP4FPgZ`+1R~Ly%j>avL{7Yoboi= zcySdwx#8*|+`r$qt)55Zfgr=LU89hDUnp6w~SEDAM z?79Aj0_!qNvy}Ud+q~k3T%ht!k?e_7x7|S*Cnw<|iMcYVp517}QZ}7tD4c8lGM-#= zAyo5>t{lL;nFxidPL$BKofcDY_+fa_g+z>a(@+#i^wbU$-{MM#^O^ zD#LF=Aru(VZ4dk_Ktv(TeaZ+HJ<}pyVf1ABgEZGDV%sik0CK7i&}>82$US}b<#6d| z-J=*95cZzKh_XvDCY)1@n#ji*o(bTS;PMY+?<7GtFOOEenRG#Hq9#SfUOC54q-8cz zn2}x3zm#A%ET;-dK9CBY#WX4dEWvhYRb4kUebHlaRr`{z>zc0p%+i}qy0x<`m2(|D z5n>0@f&zeu=SB1M|3+#@ia&yts?a1JdMX zJ~@z==|cTlZj&%NWoL?A%xSNpHnl_KFoCjsWC$(A!>;F=Wj9FP~U7z4HSL*>J+@t5yCO4yooz!eGAlN9^bIIO4hJOa9M6HN!QzFgfH;g&Ha+ zjJe8Rp*6Gcv+>z=a2cMh`sB?68j(!sVfP?F%-fFvCcbjdzv-irbk>S-PilcvJk=$; zb^`$_!GRr<7QAmjQ1`PF!tUVr zdraMT#9EPea0S^as1SmUJS)L)@&Vt`#$t{+cX@6;23C6HVN1xlkqBXx&V1UUlI-Ej z_UXdi4kEoYv%a>6ZU%kinb5bVDCHW4kcxKYRetAsNOjUL_-^@3B@YtYl(ec?vJ|ih z4-!CEq90u7AkjW0**Sh5$qs3M)<(mFcZ{f+@db-BS9Rgo;A#mit-pYCk?6;Ej3751oty*S)?vdM>RM+*c)#ktYpvfSKgsn zJNW})g2}`(-@^P0E~Z1fwg|D`qBUi4|AkFRWV3cfYTnn%A|i#8y<8b@qxQ0bx-t-Q zJ4SaHHA_u=75u-^pCG|A`S?}*%st)nN>f-rqB>zzB1AEdzkoL{DWsKMX>W|Iv#jSz zsX4oVBOD)V`b{Y_O?Gsjk_#8$)T(x%=DV`aSkh)NJ$bG!g++i-dKFI(wW<_UB2En( z2*L2dwv?n?9KoAPv<@7-FF>qvANB`{N{b6^0GR8f6=g^+$pkaj*=L;c9+7cSe7`b* z?^Zz9J?SYRfKtYNQ`MI!S1W6Vol5RHu_-;hd!=zuaw=qp3_<^#UI8e(kLhfLR2-O{ z#F1Ro3*J+Z1Y7zvyr-Pd(6qt71KQhayY{b@A|`DzBziruH+yu2_zN`?9Bs}mJBKzu z>%XGfgLwS3JU%=E~Z6(jDwZ8Q>__pRn04wVQ>^)p9`fM%`ANpLcLes)U@e8;!PSTON4e;Ri|hKDd&(pLe8Y@CJB5O|Cj=~kT4 zV)c<`ub~-ZJ{rp85#jB0*ry3uhX$>tFA;d5~MIioW`mFnMUNxiu zv0l(7qd0FPnp5xt%5O3N_W)oOt}TD)Isa_l;ffbr2}*O#jmlIUR`$gc z+PTuQoQ-V_tAV)dx8@{G)~R6ksl23FPQYc%-OnP`zpvBr5?2;P!LisxN~fNE65s>5 zskX7Ggq*I0eiFakvrbD|;P(+iu@L-+mE9*zV2LzMuNYB$m08B%+v^Q_pK||L4g^!K3O~A*Bo{;QnKW8NqDHxkfE>6_W#hoMKFfs(co##^XM*{RC zoASH!+iV}|qaxL4_|#GvXq2-h97>kw)4^Glq0bkzp&Z803s!VT$n+<(8Jm#EMINa} zLTDPyy{2nxES~dsZ%mw{dby9$J^U3963xJ6@1_?PPd^*Xm~)kQ^>+rg5aIG0NyChv za!f~>PxQmo-f53B^8sAwkzrWbCUMLS(H|{?fbET+rT!1qC=CdUsE0buTbrR^LDG80 z0-fQZuk*hu4(j+qL(Th1Owd>IUVcRRJ#&^@=KKWEwkK?_nM>dm&CYg&)P^Nkfy!<& zZL`4!oFL*hlU%F9P>`eq*(RUiQ0@(05g>^BYRVYOCq*XcimTWFPtx&T*2}64bh}0- zp7zH%-IufI;4gHRcxwrIgYaOeX-8)zl=_&$JLmo1=?r`^;grf@%GMEN?17tJsZlO; zM$rS>x(r@Qy}$8XVPE|gX5dDOroO^z#?1(FTzsv@MeJN|6@mY3Z}paxl(`JYO2$(> zbphu(n~s_;pC;ZN3PHW~S{DlqYS&@=wv5vUp6c>_h;AuEazUak%5-vcSKZU;N1Dtb zha%|u#TD{OIr2Uk?Bm~5V9s4~-~_y`wn8MY&E0EVOtGk-d>q8}qfnI(s-|{U&*60b zCG{v^=LS%4r90T)4Zs!FXmm}?NF5Amwm!?Ovb+yNfcZL@Tu|%WYn*EDZv5c{D4Zgw zNV!}g;tl*g6r$j%NB0RLZ}DHS|E{;1q3*ICBMd=frv zUBCu0T4n_^yAzyuJW>xqOEAN?)Ni2tqo2mkCEm{^R-|9+YLPyxMiVPG2_i;p5EX~p&|f96!bxG|9(U!Xf914!J@&de$6=cC(TOPb9tsFz3XY<& zct}fm@)!XnPaK9o`k?7e2r9`&k&O?+$aJFzWLMHOTtDYUbgouI-2$=j=6`hL-w9M+6T z&67Zvbzx*j;rA$4tYk;#cvkP7i}M#)c~Dv9B!`!ES#f$ZlO3I-fZLJC1)*=X^8 z#>c1tkor)XhIjmQ5SnlTJu}o|%m|BobIL#Fy3{|CxwGq$qS4<7ZK2pO5YA1MXkot) zX9lvp0)N>S?jyY7yHuA-LGVspEL}$`Q8%*sRqR_Mte+Kcayc%}h=X!KFl3g?$w7zZ z#@-&J<|>y{AA`0yL@Jpg|45SwVAJY%!H+BFEMdkF3~)>~u)Uc3GQxjeb%UYzmON0K z_?#R90Kyq$SuWfFEQ#jr;P_RPetf*oMTFSkm}+?M-v;?K|H*NwmA{l#{)9ne^w}8_T?N8E6<ORR>a1imvUBvjw+`RFr9q48s zz%WdC6928p^P^X?YHliDu4!e=A@g@%T~cJgD$vHPHadP7o3UkY?jT+1e%p%SnrLfs zk+n0fv@g@0EQ#Vg|L`0NiE7yH>0$ghm_T=k4S&(;PKvy3=qMIy(xx1nXVR-Vr23 zATJV0;ov3=Wv@6KKWsy4ni&*Ga7Xm~zI&JPjy?2yQi&Q%(x*Mp6r&!OrCqHC`zW0K z+5vbLVkERis|HOOxUbb6+5X{QLVmxLFGsS zBvPo3%iUZiuTMKFG&)H2G+qA!{KRGP{ZrqhQN}G1vqqEjD+Hf?A>4gWhkP=KCLoY! zKjHS}$7FiIAv)31yrNdSrb5`tln)_uz;U=uoCyP2PDjnUE)Ss&X?wA8MM_8zTYCcw zHvxTrq%0e{0UHMP2k7$ap>*%;f?WN-$3;a>W0VdLEG;#uciBJY(MEZ6PBAcA14|hg zF%*#*FgXk_iKDNmBO-dNit|W*$f|F8rHi?ml0B+{b!!pAiqu~d9e)5XWs>=ix>WM zRoL>j^xwPrvmliUCI`|HKxT^5D#v!!X^`3T7#04~!A`d6<3mx;lEa^}VMuRy%(=JWnJ8 zK8;9BPfN@8117B_6CHsRxtl`RkKTW>8%uh7=ApR33h7Ilocr|wlS!-6MI|g(uLjp2 zuLlS%Quoj2UspF)7IcJM#~?$_S7Jy#=JHl}kqm8SUCJ2V{PPZK6N2YBcFsZ^L2drqz#o3j@|**;CSTt=`Yvm z4%7cix|SubC5uxS+PtHrC)k173AI4y%vXiXS1JwgikNfEqf14(ex7*F!laBiX#_t@ z5>j>Uab1J}HYpt^)p2$-vXV_(Gtw=f3h~u|XoT}S;G8OF^AP91&QEN>OsEN?29MyY z68)e&1qRPhC=rZEOgN9tXWHNLYPg6QGw0@Ph{?h-@IvSSQeBhtx`=UKYW8XVM5wh} zd<@*_5H)*5E54@_aWRt0I9+7~C(Ub)68i_K60L?5$|9SbJ10>Impu6D$2CLlQ!3Qs zgtbspI&a~rF}3p~WV_oK)Z+A~zpQSW&wpQ;yQhKo+?&|~b^ z%w^{k9~?Qql|^U85BKwz+fV=-*a3pCQ0#%JL{A`$pUJyG{$bC%X-{_L)MYFEtoj%A z!-)@PPOC#XY|?Dfaf(+9CAsWnSwoyZAjtpczb$uiuJSJ>)L#C+D*r#@rQR@&uRSPkn@+OJ0jplBe1^B&mV`YJ*d$rtlpQd8FPlAtWu5~kkP`j-ac%)lMmxR zi*rD5BlG}=__&$Qn9(RUYU6Q#l3D9tB9?n3 zelC5{ScHCkQbA;CfjV9GkFRH-0Ty~GKy)e;=aE6Rf`qZ?33z6r+ZS4F2_0FTbI zfAP({Kn5x!00KlTf{?`>QGxtl`B&sC)kewTw6>%2NJ&ZCUol}Yle^zX0)5G#X_c@ zk3cm~x^E3(d6h$Wb9^rja@O~32_hR4H-Sv-c|YVcw(qExp(mgY?SmuHq8$P+iufF~ zd5*KtTl6tPLw|}k;=R2!T@H=^Rq*($;Fv`4ULx5L@B1tk@LQ6kZcuNkSMY>y z?5?97rm76|=pNmh@Yc&)^z1yWL#8wGN<1|lKV4xXqvGu(s7l)_S$X$NGRtAtW;EO~)MXOUx+hkRLY5op3W zXzXTPTQS>WRAOEa%Flp?Q0Vk5puqdH=(OkK-S>H*!eSo~W(*B&U2YcsGkS}!T{O{IjK7ekRfp2c5U*4Vj6vm+B7b$k6n zhL^pF)t+1~)Y#zpBeU7-lBZ|Y_|uOvXiYdeu)cu!rYN*Y3?96b&q8^z2fVPQ1QV3M=ND+pwe2GKTOs%!+mri% z*L#ff#AxLBU3=iiXu!w>U0O(CXK56KIc6@Qn_xqXGKBuMvbnjlz5t=tA{o)XSFkE{ zHy1XFqw7s_Fpn?L6Q}V~mmpaU6;wHL@{@<~LwuXNmF8hT-})j19mH!IInu;0icxD$ zVvQP(5-{|GahN{zZ%pwDobyH;bgCtZ%$}+Z4nF0C#N_w6cZy8nH~3w8f~o?{Lj7b# zArAJUUHYFUwHCl;$svkoPvmCUtG+KLrANv`2Tg?u7CQqhYV7wFqOiwQKD!G2hF4!# z)ws&0s2i0uhM?nkHsd;2&CT?8V&$7V8>#NO$!Kq={|z|C_FsTw3>>Wg8#uLQhX(t5 zMkZkO^z^?!M&`Fe&89 z^`Of%KBF~`*#5KUlhRRRu^F2?txFQt&hM!+SuEHyt{wP-}C~E3;@$K zGui;6{7+I`?R^V;!~9Ku4`M%Wjn4t+41Ub{&;TCwa({Kty`9s_yR)ND@g95a7!sqx zk}B$uwtJ<1Y88ctc7XS$`})E3^^f%d>+0(60ovHp0DFG1#OD9KyTA0m_sI=Rjo^1* zRNJxMA9546zc+vvzVHyRd%i~Fo4(Gp2>jor^DgNeX)?S$>OXv~pS!fbza3w-pre5U<3zZsSQzbqYuFRUg1uw%!D zPYlolt|zR&+oDotkW%n@bz=GrqFCk?*D_!iiUohvJ_^4rj&Yq*ZuY8rzB64>33{V_xoQ)L7dYJM7 z-+EwPnN!{mw;#kOpau-AnDd{lER6NYV{ykak7X9ADWqacFy#Fx{B)Cu4e5VqzONhh zE)K+$#du47&Mk`_#wK?EixC2aMrd%{A z2@7G#Juj2u@#1NI?(=r<7=fCaG~oEq5UqLxfXY4b6jC=9%L1&X(0qt?Rxn=D5)-Sc#i+ zE6WjvNMzZvnG4+!JRF2$=ZDt1d_4YXFlem}jC|JT#L)nX7VgA;XCcqDGPhLgAJ3>( zc``7VzuJ&E1)(>nZlZ=($2!?)7RG$-nn@ybAk#5nGBroduM{(4=c#W8O-)EbFE2BL z*9=Lr9_910RfzQ}xF6fMKD3Uba4#Eb2cTN$!8iD#np-*g(pmk?_vUn?l=g!X6r+W* z@Pdb{C$UG`vZrwxnR0dj*@cfD0?AhsMqtI~&u$A9(qTtB75(Te~kY0 zt0F%wNh9O-LF&68;+HVW?!LF-O^ry(8?ZnR+hhjp5MFBa4?vK(5-kWA;!2^Ez1Q zeWsYyj9$!Vy8{Y2Eakf_`1BnJtg|vWFaB&@ZyVB$;Oj{!|5-FGlenpr&0JMamT)z% z5MZCRvzd8Ra`7hb&{k%*(C?3`B>oHa56m)=cVtKh!yEMVVddRohLG{2#I>#7-T~4w z4!DW0b&Y;Q-};Q-HCzsOgpnizev)5@BYh=T`1DjOQ)Zs&!;HYaHlDx%gAPXEtn|1qPf-<{UEgw^0xp-RL5(l#B4JY68VIz3dU}`{ zpfr!X#TBuU*CJLgZ`{JqFua-mv_O}2{pJuZ$31MDOFiTX%UmAHZ8Ug) z4u6jZG5w}$+DCX5CONTCCEyALuEHUZ0sRF2b}~DRoiw`!g06j`4W^TZDPj(`79Q%O zPM^?E6}9i80ow>h7kj0QBCEbg{+Qq%soBiW=Jl3@tp%Dc-B<s;AYlD)Bj#ceJ0^`PHH)8r{$ zJhT1cBqgSFf{sl}w1mD2I}%7rSGnN8P9NjlFIaht!6%5uOlKN83Hsb3GHNDY_L$-g zNnm4408^cIJ#Gt?9R7H(TOw+bWsdD=P5%1UahuD*t$#;)Q}W%j$sf4%K5SR*+h7}ePfCD-uG(57Xm7`D7>lqEjNt(Yh_we*xCG;|M0*CP82v>~z$fdU z=kxJKtQlYp!!;Z&r-@rcNRjV~uxY?UQkOZ@s#1r36o0xL!w$#jGD_~;RJ!CI7g}SE z^lizMv)(gD`yjIT>zX!$iy%uGmIZxW!||(flyhX}kM-tamGONG-bE)RGAfD0iLwp@mA;*I`vbJgN+(_X=hO-u`$lrWRM z3?vpJQ@8IHkE=uDV@M(0{1E-&hpRB}w)z#l)*Xf<3`LwfD=t1UEXC|c99A!kQ#g`X z2cZPB{}O1UK$c#5D0>EHmDnXzk>3)kcv|j4@6>HT^aiX;Ti+6?&<=@G4fC7!a|s`{ zb>jeCUc+QCJ6~cT`Fa`I_3q!9tDE)LsmR=>X{}nmXmeP8nBg-k%&m?8?xYY7P^0P5 zt&RUzbF$loIKmD(++O=lkkBCc&SFssWRA^(Hm}ytMiHP;$=oYQs42AVIm5@ENo%iR zG*C#|2;272ZyHz00B^=j&a0cCP_Yg&;<&wIG{vc|S%g?iDr`))fV9BEWGy7qF*AIm zdea?z^~#+}o*i0Nd$yR$*_Tfz#DCDAq)q47EK27ey8(F0R!VzU>lL93X#kP4iMb#Q zaHDqNHMt;ppPf_p-Kp1##O(@w?L=>PtK1PfTfh!7`BI8dhorZDj(c6EOW-21r4f)1 z2%+rKBI{b<2S3igKT$Xm`^CwLf{LqcH^TbTgy(c6qL@}`9n939C!h&BG_orXXokOdF+=r~4Vx1OzNHFR-iRxD?Oa^5kB=0zkWV=t=l8K*m3#xiJ?M>=4#8O)!=2UJ0h3CsKd4B@963t8#B>`(R@ zmI&E>v=w$lem|e2U5EI1r1~;nD6>LzO>*#|QW}sO&k1p1>@yn%-)7ViI=tQneef)m z+h#@%sFxmghv%OE!gx6&v?L!TqtafEYR5L|WG9^NoKW;@3L(TLQp9#adeV^;gjYs; z3`|Ir996z7k{dTD)x!YTpw2efwd7>uz0_7Ny_G=sZ>?;DoJLdsv2^9jdM5T{k?{q; z#Os6*%D4ZyU!)WIgZ+kb&t58q<6RFm+UaXEw4qDR9@x`!gOkzOOO@W321}$o%avrN z^zJ#ge&+XSUaZyNt;(}db*PHj%w*U7S!Avam9$%T&7C1|_az$}yMF=#ExDi;oHaHE zzHhLJYf!$vk$f@01AN>}I?RM1e8A3Pyl9XYpA1n*v)@^Za&1b~5_Xp4SE}C;&`(Zo zOy&u-0evg0m|g#7P}89cA@x}Gah%BDO>fZ_)eX{E?ofrO`$=*0={{3}(OLB4UhKl% z{JP%41#qN$swsAJ8z0&(vx-jpm`3V6_fTH7QD~4jZLPe zz(#;B{<#27x2j zv}>1EUzZZjts>KfWb0;0mIY$p6UcgIpPU=tWeV$5VMef;{X1e#c>k1PRpRjQx!Okf zl8!rmbCm*OC(NRR;wpm$jhGQNji3HVeu2C4ON`+J{@b<*r*mdPHJqmSK?ry}(n)w! znaP|dU=sW}XA(Zq!Zw`7iC;ixt(hrdS>WW^`jrT1`IP@a6*UJL2)N>w(_%`1dUs>* zU*}?9(Q=5R%ao-GOZ!PW`n{mcKz#v_!4iJY9G|+qj{W3uqZ|%$p9jwU-AxRewO02! zXZyAZ`HpBJ0o2gx06Mt4w%ZjZw=+uYI9!v@tp95j1eF{_O?UPIe~tp0;R7p|0#f%w zHU0NIG*g4~ZEM%%(p_W`SXTETiy7%l&0%G_p}+T}27l}pb~Z1nH{}9HDd1v8NbB&! z(AhA#(vbAWecQ4@V8rd!X1a6RpRXt<^&`PY-J_QRR95SA)4*J{kgC?gI@+*@Do_p? zl-ks;h^DI$GXG?sm)D_v_W{zmH3A^Q42@-rUJDExdxNRnh^aUR0r`apb)O|5A8xKB zV3AB)Z?2EqBKrQgZDyVQ4D8UiT7YSqz*MGg|>U`Zq{_cAp))Wbq z;!xn^-mXE3t+vpB_|{uliTy50&d6>_L-nKeC~G9tiNY3CC_tBobn<;G@S=1!?eR!~ zktF=lyYC*ROHa!|9SWcin>~^VT>pc+njo9PmNObt24GwoS(qC)QA%g_5 zxw~=kz=a0`b0fa*;BKh&w_I`Hlwty6IOd=su9MfzZ5UFSIK80=y77*0uL?)W`Gd>6 zf}#cb(NIy4+o(DHE$grBb-tc!|MBo~lqfs}@QdI;`w#_ZQ3lQg261si<+YLB(&{$X z>c1&tID&v3#B@_{P+@AbHqrwLOa$emB-{)4tA4mmgc1E7f!wTJTW2-*`BjGZpkeU- z`lRS*vDZ#=MUWQF|2S!|+%j$}piW1OlNc?26NLxXrgjEAC_wAg%57W%M%ob~5vnxB z{82jxaa9}e^L_DD0+`ovJErE#(|_#LZ;_}|S1qtlt=)m!FA z+C5icC}*^5Wm3isTeTquuZ!1cF*_^suhdm;u4Uv&b#~2Hks$w2VWhR)Y3;&x1)*is z`KQYQ&qN?ltC)O~V6diQYZioYy_QG04{~GlJti8YQ~1c6#R3L)ktBY@ri1;U4m9s77r~rJUFP_EyvoBMavh9BPW4$J;<%dq& z;Z6^hLl=>*<31)FL_s@Rxwx*pd=gA0pwsO7ePn~ur%a~p(;n!XntSlsx%;|8;(^it zWeJh`)vF0H#veqB>Gs>1xU!#i|8~`Qn@6zMd`GA^0q)EC>#S0Pc17X+ex!+A#8j5XbFU{SK(f9zZ6p6}h!Jp* z_f`4K^i&VZkj>3H-(L?`blcc0(J%sea!%yB9RXWMM=IWl*XGg#vw=3-+MbN*(f+ME zZ7j0b%%&EAB$MC)jh`wRRK@oGsL2+>LyND<4MES2eS}wnm6*BkkV7*+gn}`baTUiH zFYsu%J=JCkwT6a~RVOERxGHiDOB@(qV52gBlb6^WO7n{H$zw45C-pG8d=c0fUi1RJ z8Np@CCR6VxrX%>qlx~su=JN=-QyOaJ)X=7_qZh8xvtPk{Q^Z;W}@5>WPon578<@cIrs&REXxZF4iYpdS0c#Q}jw)-uvOI=?w zja=aH9!NP9mnr2RgVOW(WFfXWPdOnLfH*;oD^7i&gT$m2G2oYsyoZYOV~*C}z%dZXL`J2wB72U2T%;ism+juihzsBVlz*ITwu5KJ+} zOeYZ$9Z~?~fZ6;HWA6|vjM4_{F59+k+qP}nwryMAvTfV8ZQD3IH#x}}{DV8}VGlap zUC&!p$(btT@DXx3Rk@wvWxWXYQB%t5z}pNc;h&%oxI!rHrE)THK>Wh3$Y_A!`Q~Ee zs%mqkua(I|W0omXUfR42i(JI^E!bS*fI>sODJDqUX~3Zh&r|~h$6HiG zC8S^1K+TyPnm?chB3M=!-9q=zQHnG5AA}jtbj^#gDNS)RH#_L^6$SLedi2WKczfz7 z)Tqr3ZYLux^}6}fj0GY31-*71#pj4LI7C7SR*>zwI!S(3RWxC@$IufgsIUH&1BSg! zH$iOBo98gYj7?SYLWBMy#0G$!bsddTaC1VIPHYZgN+oTzHD35p;U z#neMOZY?*kC;dM0`|IikRA9i7i@ri`(e<`U9Ir6NpZ7Is=i$K19x+V&CY1j{JIdAD zpPXP4HQ8Qa;ag4d-)X~~OhBM#N*xr2NEYVZ6XDt@U{>T&gcZ)j{B#G5>NPza@luov z0gyUVdMuI;3)j9XtP?s5e{W)8*+k?Va6+ZIQCN=L%i!a*&+O&=A|O?xFch%#&*=IjU!I`1TN_l^4nX&QDE0=fms}=nH`(%b|0=y%bYO3Wa2eBzAq?YLXKoDypH$oMm(}FlLKhql@uqJ z0N3-kKUQtY4E~VAZ}+3#Ns9J;fZMY~AGUKe+N9TidQ0V{ff8uLEf0Tpgg-BT?-nej z-Djm^IpH1lI;zm`eKdKUuF0B~>lrM&PmMC7$~6)ML6;Ag*@FPFgwZrQ(zdpKNURT! zKdptbCgfN*VjY0Dm`qSK>Smi@lZByNXoLStNtB&&zRVZ#dEIzABAB)TOQIkiC9p9& z*@*9s$aLGh1aLo;ijY9iW%6mt? zX~5*6`Bn2}npDStwjr$`YRNPq@2W@j+Ie*au-mw(vf(QdV|h zJ3Q;IfBSu_*PKclYVuN~A9fYihLVe%i~i2?Ra@{lhCHNQD6gIPPwPrCn6QpL$s#o4 zU_3L05Zb2bn<_tg!-28l=%peVNeu`K0<%uYTK8c5KEpsencJHE+z9h@)vqcC@1dh@ zyUUrL@&Y)$iBvh5Ha{3_n{$(9#1ATuV2V@pig_s>cyH6PS^byFrT>Yqw=cb-$?9vcv4h4?TAed|&P ziD-bTvtXWt_lK+NLQ>8+E33osH;8O^Vay&~JkbQBea5+*?V>u_ojft(^K%K7zaqZ< zy~~oL%38PD=`&TF6WaDODtw~XXs!t1g3q_E?MtXH;_7IbQIx(eBgH75wm*OG@!dK; zyFB&U{Pc#Mfm3b#oJE{suHeUsK|yo)z&aaN@OFH$wlq5~GJSl$SD#@R>>l5%6Dt0N zw-BP=HA4E*X%T%z+boOIat-t2^QkY&iYa06BY|wctW6nZiG6}9!e?#5UF&?LL}r7d zQr}%pU5u0VtUX?@f!h{-g@B`)eEjnLRuP0y zvgUuXlZLe}7h{-MNOzZ%ZHmATyOI+a>6I%yTIb|C)QcYY*?_mG>f77Si66IK>FOi? zS5Insw=!*ol`lFagz$~KTm{dPO=nN5iTDX;=bkq+aici0-02~SrAvc+z>~#*kx^d? zZAiTs%0RuxxUsWi8${+)96Uk!s_Z+CxGeQMeFy;?ivqh*vgVKJe)@}3sp(4WR z8vCN-?OHP*rcxC2KV>(M{5O+^#|pE}wU;ta>_WuJ(KoXWuM^=pPKPcE^F1<5sr}(e z$A07Tmf7m-Q_D>r?H#C6Gv1zP`OPvSKkCPCLP1%T7A@E)9QXAZgqV!`NI(1R;RA(W z<3%$xOP!1Xn>=9Nv@v|FV`^iiGeyt}9V|=}j)SYUlt(d6A->j#+y?St(R6uMTk7Ho zISQ=CXBH$M(cZ_La;5isbEaIa5NyH;$4reWsm4&#=v@-zB>jleuMKkI^O8~&5C|}K zEPUKu>C{{oms-_0XoB6xr7^TTPA|AQzz#&%bcdhZKn;mDeo=H4DyJ}&5P}R9nKkvd zrjf94H)tqDGO45>)@({W*(-pcNM4`6V{oe7-RV!4&W)3{7DO+W&$NF zs?qAI9+u~Y zsrIQQ1&#IYA+KwD)F2y>3=ozaGtEi#_3`SL8Wemmhm1LJbh*rc;MZqip(xEns7 z)=%Vux3-$)t2{Lxf;@umO$*Aj1;z=+b|!uS&2J~pT-s9rK_CJ!D0|NX|9~8t6AhAQ@^}e5`7lDsq;lQ;Q_-O ztjj|-bqyGj3nUqSbw;wk&rDP6PvOG*QmK|n~2vHL}*C*6KIYUOg+Wj;+I zdJIeLPLPu+o&t#P-n%3qm>;9$oHP5#X)jenhs(+$mFBZ&)8@xI1#Wo%j(Vcmi3brY zsgHl9a#6!-BD)YocgrqbAOvj`=Zh5Rz=RB4Iym%!pwTX>O<07Fvi3Fc533U23I0JR zhKu#o)Ab&+n@cxPF4|%$`yE~HlW97B&Sb3_&Yl_p8E7>x6{jZ zYzW$hl*MtPJx5gt~--bjwBD0~6@ypwuDr$fNPO8W6`AVW&20NjOB z=yRc%Jwrs6!}v;mAT863jkIR6KD3!c#27+6=BnJ0oIdl`y_+NH{@BKS?^8>zGw17c z8>7EBnS)N=^oN`vQs)aJqw{Jal6UUBKibO9sS1U;v;W~!&HGAAknZ7$(O?h-ATNaI zG-31$rdqf}H)8Yk0xviWo3thnw(I7qs>Du!PW~yuSa0#I={Onnqkv?=salFIbZ7zO z5`BDZ7O!DqCG+(h-Fr`c3Co_c@rjM|~iu0l5(QYu+1 z`B4_3Xn5F5VXUy1Q$-<*^=Vd=D>L6$M2$PG?)`x#w5B>uhTt#m`qP_3;k&Znr?J8f zFeJ4-32cuPy@Qi!`UX}8{!*gI$)`$NyYU|RA6hA|L&qd!E%wfRluZo6v zfIJxUhD7R{X#{xPmw=G4Xgnp7uCXX<@J3QpLA&NS$9uFl%VC@#cV(re@uO&!o}o1>9eG+*)%p>N$Eih zMZx`74)1D@%C@15S|ai47S{Qv`Hf3hx0Vw$6*XiJ_4W z_%zyS_l4mv3*W+9zd@kD-CmBq8bstk8L*_g;5c-ff@uIv+$Z`KhRu}G8Pn&6Qm=uZ zO{uvUG0U3%IM8i+zuAN-q%`MJg4XwPo_-LI*t%R-xv-a|XbE(Va=l@%RjCV%M%QFm zj#|`ZJiSZ+cys^_RX|j8_4Y0)dRO=*tDz?P&f%~<;rV1~f)XC`iuESWC$Z+GgjX2P zi(ZXdd<0d2IOeg^Tg1Y6dJ?6<*VIw?EGf+JlePL*7;VsvU-njB0HEI*`xvOS%li!g6Czw4(R{k!d)Wrx| z|K;$m`AZK@z~;}1)F9+`_9S(e@#+LiiA0^Zh0bZ4T5N1sY%_W|S`D_S#R!Hzvd&tr zC1-~S)wSzfBCJ0bCZ?e@|ABG~azTaF8b6H|w4JY|7OMz?(o7Lt0|VSU>*dz866<(} zkY6;S%=@~0KIJHxF#Kw1qc(b}d|Jh*Oz7vK;h4YN%1C{A?$8S8<<~PqCiu{`+<kAp_(57ARzk`YCjyF?==hMCBrzLQ?G*{VCzMJ)2bclbUHHaD-u!8YptjUr=#@=&_kZJB0tP77M^qlH&&w zAUb9KLe^-b9OiukPz9(BR(Ly*SG^2N+Zoc704MFe@P&xB#(%5YV|f5RF%`()7;oYOHL#UN%(=gBaQEE8Vew+obZ(_!STG*Yt8T1tqm%qC4VKQ(Ka}4$_76^X*%dC!G z)LV1*Bae6P@=A^V^&l}{BJm(^**ZRe&hI3<<7x~5{>)00BD`5MttNPh& zcS>`~9!UrxaU5DTP4sK)zEdizXI_igD&$T3uytQz_?5bHYPf@-5cY|O)f z3;0c4+NPNsJvkbQAeZH*7x%hcL)J5O9p;4Gc^+S3HtZ!|A#Y5K1oZ(6UOMzHQ%4^( zWUtq_IHPzmwK*g1%rt97v!9ymD512#wu6*N3=wP&jxXKL(;rK3k@MegY`e8VZU`?8 zb~u$~_N`meK@1fCxW8V+M0V!VF8EVIblw^SlA~1ex(}WO!_aZ{V1;diQ+UP7`a8Cq z#whcOug+xuy`1nN44Cuyrokl~b255BdLxd+QYvjKGQFn!P@mSaUbE|>A)2?iDdv$CyI7yyw2vk* z3P!m3guC{ggJnClnLcOBg1Y_sLBxhZkh1>r1-O1fi1xrKwpt~5UeREoy~IGr zekqRZeyId4C!iREaHdAWvpktu*0?G{1R=0xwihsdhuWwSZPY`@tq#@WJM$X*{-n!x zIZljHfzlI-?d6o z5$P#^GSqHENXOj)Tm93soz!|M(ClM?8-wiJ$t~1ms|yi4-=hgQsJy z$Y<%hGBB z6G7j~;q^sw$5`3heEOyp*A~2QPNUmwy@#!7g}kBlQS{6H29G1eYh2>_tRnY1%9|>F zky%;<0LdzvDo!|s=a#}ILWEh#EJFoOPx#aVR*%~|{xLxB4#N@@Dn$*NDdZ=B`^M1i z;Db)meAVfLm3HSAhjNKkZ>&xS((csm4QJdJzOe0~AMKlem{&G2c{RcjVTapQ2>ni) z41%PM;a>Ve(u<2>5S+A*85~F^X>=}RK<&NvYCg^_Q0EsC(#i> z4Vw#qeZ1BdXx%g*welK;JQE~f7XPRT>_h%4LjH<_ExcE#i`uw-rXv zjWe?nVAP2I>?v;#JnM=_g?Qf}8h8w}~;aDiod{VXDBHhFf`x*>|$DsMqQfWVt`w#~@Okso|d*4Dse$2h8j= zo`1MlLXPXL!Y^i`?!1(e&5=3PV&d(M*LaM_#R#ERmrzft) zVJd{W{I8dW_O}HlragBeGS2NFzOH9J!}*eC>zHpCIp!}&GHyvbKlW{G+^e^!fK{D; z*W3ASxrza5U#ELoiRN~w^mN0Ek$^3gaWrP^=KLki%-d7=`Bi;vMv1jr-Z_cK*M-N+ zWkoU*L0xi!q)>Txx0Wa$6cYFQK`N+#Go5i)z-dXO{iOVkm>j4=ST zLmMcQPRoWa0+m0c&|}R=1M>ESRbF={`w~X|9+t{9R4PqR&P#_~@@-7Eyt0yk5s0ow ztNQ`@!-YHz$>p5VcLwPNTp7*7mgYD)Dw7R;ns<}H%Cw-r-&y5I_)gYAiQG+X?F2sD zn`6tV{~#18W@35o_a4`dIon@ZOp^Q%kx~#R(<%Uhllt+)h%-yixR-_^aW& zleW0KdJ#mxb+W?IMFS5GK3qRxT`-{~iwETPf{fYAv%M;nO5}e=EiU1i1%qp&;-<}< zXFu{JA{pyusb2aaB?6P@{g3qJ}08$n+&?#(vxV%%(^<73F8bymb#`a!Tx zEQNwfHy&|Bc!S*Wzc)l{P~tGJY&uLsb30&**1V4nQI7QHB?)k*+zOQ2UM88x&tD)2 zp*?kTUEG5pbSQHAQ`tpx!1v~}H=AT_Yb(eKoE#CO0h3QQUaJF62;vge@@XSb)V?xz zQVQ(PmAZ@g5+G1R6BFOFeKMsB;v+C%|10L0c_i<8v!8%stCq^Q0v}+lD5R(rx{3tT zQj1srsvdD&?f4oo3a63ThNrNQlGJsh2Ii108|!X~!17qvXm4J2t-1OrBO}5GDZ?<@ zM-vgwdm{&eK)5Ol?eK|kk!vM%ZXTZ1TJ?a@?^87x^vnlKo^3KDmz0#=UeQ;+7w%J| zw+XCv#42>^c3R2m|F0A~$Ebe0JD83F7Pz8t;Yd3zPp?;VZZH4k{q+85Au~Pzm2_ef zy+3a;kSb%GN4<*Tm*4pxn%e&| zIdc9llOr=5fJYQWfVQ6@fC|GB*s;CJ0i7TVHy~!2~0!qh7iCt0Se(F&ICNbFs(1Zz}x&?muDRnrUg8E575sY4lJOU1#rI$ z@GtJnCNO}DC^v9c;Y**`=~v3xeaeYJ8nZnZ7$nSP^m8Sj1_iL8y~_=LmOr~Ccwoms z&mUe*A){oaj*vzdhtt(ifgC-e@LGR77xIdq%^Cu!e{N)il%gL#fCG@=7L6^ZZ}G~5 zL&%T2!$0$m?Eb+igd3>(HZ0&>poYNRUqf%!Kpg@g(joBOra*O zS|5nPFEt!mKfiOuz?}v(Aj4nyv6#-c4w^gs?Vo++AKXVDb!Zg!*xNI5ga zC0xUD01>Utufs{a?pylk^*@FPux-rGt0JKN{nNuw`n}wGn(JFWoLTpf@0+0Qi_?74 z69Y7dDSe=$19X4@M2LFu)t#t2xo-gaTW(S

2O%A!2X81aUUX1aj%=!We31w62>`ZOQ~=2OBywE z*|HkUMI^k$_U^@%T^0CBj^`3~p8DLL{BLc-)&iEQMw4z%h=VKRq&)6dN$z#Gbb0tb ztSuECs&ob4=jIO>;>C6$iT(#5%5k2fB$&KhNx@jjsr%vFyTcO~9D=Lkv^7dJ*lBZi zB=)`O15onIBgJP%6>#y+*qp>2fS9bCkOTW?%&v|6R!nxBR_SeSmS(bZP>V!(eHR`UwXfe8wZgGf(ka-VQ0b>o`WYqpX<$ z;*)w4?l)gNR8_5EMDx!lUWQ?l;q8V%ir2qzVI+Kl2w%d*uC2xm=1iN1^7DZncB4rX z*s4dx=(Jzo_Ulxo>=KV%C)4@w3H-)ou!dfJ=RHq?vh7()Jhz*}wPf;nV;9TY`B*Jf zxwL;i&onusT)mm+J{ygQsP-Ax8bC`BHj+vr<80HoO%8ijuGl-ySpsj(m zVvpBA6Mg7l*TJ(ac=KT)hRK0Mr^W|xVB6h}zGAW&{Eq81;->&7=r*JnBRntY8o?r4 zdXYhSX}77I<#P5V#zqd1p+Uwb?h;4$qHk!YR>+m=QDfr;Iu#@#)yrFnv`HJ;E^uEi z>${h(MDJzH|6LCg-sNygT+nT>hKA!O834uHu@VpSp4Bvw_TKQkLEEfu?R>_i36o8n zk%fc%l9o}^-S$^@=;vqpwe}X?_G)lnY#K&6QgY`jl-S?1($J!+(`FD=N5#gvIbVR8 z>tZ3#S(*0mpYrZaLRF7T&g$w>S-PqaQ(YOp3ZsBc=SLlGQ33@2EIT$5CXu8}AB+ek zXc{C$%9TcMapxpJaNX1iMU-KAHx&P1KkAX#w|u27@>naKocqk}vP6QZTI?&KW*Lt7 zsaR>ySVv@7T5!dwXud^8myr5`SY=Gtvz-k;H2vdA?l6hdI4z+N0sCjl@HefH$M*() zNQ#jga!Tc<%{Tlfa8&Ebi-_<{FlSY5u0Y;$+k^a_g$TlxO_l;(C6mrh6Y|-oSJk5s z9ZfiTkFFNzTL6N0huMI@&D<&`NM_dT3)|5SYErk7HKQ zATh~YdvB!3vosL8V^~9K8S*s$=L_;OSf29=Fn56VlxsdO`QWKOW{haC7d>!tzjZo zAHt@^X?6pJn=VLWp2I^%anSZ$6rJp<55EV5SbDr!&i#%ASHND??D5&U3NvnuYdp;9)mJK!zAl z`UPr)kFsjKa8so#2W^Gv)z{bNH=iBasO#4_NL`gbHu*m(1ycIB{DS@JxT)u4t^(MZ zE?B_6U+2(|y4Ac(O5=E1)EXDayKt9)oYVSiQ*|gDvj2`%G1gwrdXkJ6zg&+B-G?U8>EcSkeS^7RO-&k=IemRRLuJn7=VQraJwwFly*{9W~~IWhtcCwZvYT=-E4 z%)0g}61QerUD~_7h{;X$Ve3{BHg)3I6=suGl*JH7Fk`WD%Z(lsjXzsdR_$XtrNY8O zyieHvARA94O*ys%Ws#aQP1*Ps=Lq$IvS3V%yujx8AXya)%k>nVl?x0dD5)e~1sO__ z@ePaT8YSW1r{+l;*y#Mbluu*fS$aO?!f8Gh8JZnPTQRJ!@FSF~87gM6$DMxkmA{>9 zzq-l9#R+e4oJATUf@4Qc{8n(db&^kG%bdMkW8IWM9tbMc{N zw3_CSjvW;Cv_dI+FLD3a#Pn>;Hb$6sT$2}e7SYCDRY=|HWb$bDLv3C)tUps;Dr=g0 zwDaI_O2iBVP0&T(HF~w{RvHy2qBqUDyHueIlc)d6x;MSBz&bB@n~reZoI_84j&I`T z>oTl(mBXme$IGg#icD$iUZ>Eb-1|JX_@Fryk_zaY0~VSqDh;gw7`$SrYPRuh+kf3x z8>YiyT72Up3v9?f1rJ=7%UHsr)>gz)AM^kHf-VeHugo!msPj6Msd;9I>U^b?FsC%s z5a!1zZNm_vkgt96Mb2r1J!vzWjH7~opPcuoqjN$P5rU%zC{&E~0lrQ3f!}X-k>P+E ztCERuKQ&HQ2I&>D*$Cp_;X6!|q+plNUPq2*C|4pAtlVQgyUA7K+D&DGw}Km$mn_8?ho3$*tD zmd8gYqevQY~OPi0H`2GrM*N=}bxln1QS!vz8y655x8G5O~G@MR%;s0xQQL*ns=Tm9k z`u!~LX{g!0OO#>V>NQG?Q5+F~5kopKw!x}TcxAd0zS>%1dvulup;G0T6RM)!n8i*x z7biJ|Eju=Sz&gC)!9H$6wA-Toab?NpTn0i{%GMGH=?$xpmq+tXu}Y2XBCFE68Gp4u z?NV+5GEZwa&+d`C5f^GC;?h6pWjmuWE*C9-^7lpOk7UbK}-qh{C0`3oIEy zor7IghZyj8QS$j>EXw>&3N@Q*ll%;VUWr>;UMUhk;=;WP#0uN$f#@40i@ zg`Cx?nNA;8`lKD)^ewVL-&F zbhmzoc(#`5iBFz^dSP1y1#NNe%^^lr1*DzpZOIxQ-7HCL`TF*Kic;i<(uiGGuMS4% z*S`WQN=6(bsXI|$eD^MW> z0kU05J{D?x#HyfemeaXY?&VBWX4Ciy5qe%rAMm z7(s%W6v}h$;l99X)f1$vz5Lp96C9|T;ZD~s(sl5W(MLe%txg3% z6nw^8^Eo#%zCPMTchoffx-AjbN2$JZEW0#HO}&!D#TIjNnpPHe@7N?|QK>WK`eKKo z%UnwVD{rR{w(sNDCtYeiw*olIxjfktlg?9I3BZr(l->INQu}*6)VAnZHeEM@$fOl( zn3La{YchKC>w2SBC5+gIM}lWAMKRCpLIJDha`m#}Dv1qcN^NVeoq&+^x8i=I>b^Nf|ZeqC2rLD9#P15}KZ8cKR3x75M z5#=Kn&C+J89&fJW!9o@wEN0dzK3hP#<>m|gJO#L8qk={ZC}@=g8Y+C~R1MwHqf=i` zda)xS*_dcjem)$EyjAwI`u@`XdOJ7{`Qh=^Kt>4XO~Vwpk#`NXhqV3eUXR?L9i{lN zI6V0;1_S4|TWZ4DDa9Rh)pR(^Ou!)2+k;be)GR{eSm_)PX}Rv}Gw#?XRTDfAYQQO= zmc0g9l|7xzK^i?~P(ykgMTEVpwYu-#eNX(s@^HI%h1%sXhw82$UgEtYL0Q1)yO^$1 z_$c%6;p&>oFJ$)1`5k|lmhrgF&O%QAZ!;eri{!s;Dvi;Hfq3@%?9bA=WfYZ|>Wn!P z;@rK`_h-3q7BOwIzlipP$gOMLA4g{q%))-h&fx#1aWoF}Ntgj(OeD!{GwjbH1*(b zna^n5HaAX`Ik<$>GeZC<1YK7Tv~WfpNb9hT==%J zN2g1yb?<(F$xdCFiu z*T$Xe%_sq08?*Wx*7`-@9crqJYE~$77ERjcB8aM4jrU~D_hbe>cb zHxiI{IUMQ$L40KoGOwgzLO~3?)vMJ|Xl^ud@Vc2U?bD?fzv94E@hk>u00t!^JoXet zV-A59ouPO`nViW9xZ)30ne9mW-Viw%mtt#u&nvkI`A6lX#{i8bje{e-18>dEk5TH0 zfd0#=ZoTH}-Cm&OtaS8sIu=cZQbM^f%2Rx*;367es!k5@Rt)z?ddOD-m3tRUB*e+R zBvvp@?%LV6CnP(#IOH{9)SPo;9t({yBd!5qQ=Yu$E%|&3;PD; z>DX9lzh;%(#@QWJpaEUZ|IKhtx~~N_P}IrRZN1w_2RD=qC&bl(1Fg46ot-hn5qjgd z76^ue(j>r50G2O7btjxgEX})VHY`lF^@9gPCY(hXE-Ws7xEE%g(mU#=16$06VULZu zt0ym`coQcm+T73SZ_^fZCwlk1nvg}0d7F4Bkw=@!t1Dg^%d<$>$HZyrj5{rTZb&PU z1^f50oVn*1Fo)bg`vPx!cF5nlkPLOLiHL~$ZiY6k-1zQGq9%06Dg0j4D1LFfv}A)| zu2HxKp^SDesb{>#gY_b>)&LV1{Kf33p@mYZ!Kx#fUQd6VFU=#gP9D*oIkkFyWuGO& zm()2&4+F{BJcjl5D~|Fif#RIggY(qBr_!l%3oYD;1#pVJ5DmWKb=b}dbxD?bM|`*` zk*eTURGBn^b_-Nmskdx8o`h4+zK%CBC&L%KZk66DP31=fw@scniv*gr-fuX+ZE}T!_wVDq7nku57)W*6Oa;aIA?;;W z2yCQ{Nqgnu%zY~t0+Yw_IT~FO79M%kk)%ReF(l^fXFv{fN$4AsdE-9;K6e(yIJf`B z#-`78?3zu%R6D)BL=zVDVXC1)u06wtb>q%1=&Ymvt3j_Yh?4996YZ)kbc{$t)vRYj zb)^OoPv6mP{O3lC9{N?1fp1Az6qMooj3yr~2}<#p@n}wU`%HA(C0jpeD|I`QdbUqD zs*!2!0-zEzr*B=#;OD>p;T%9f1`v${LxEX5 z0xbW>&#>{DfVM}l0b82HcTYd|hy!NAaQo@$=q6vH;S!v~2nyH;Fa(f8n!`Ev%$fl? z0iO@p6d)GA;t_0=UL}g7LFnts%E;lzH)6r#>b=KjLGMF|ZUDUy*dYdifxy0LFbhDP z!oGE};PIII`|&Pc(F@?)M7@F#5c+EdAgzD{J9d<|4GsR|XW6&~b(MhgZh`&3POI-z zfzbEv&H&#$-+v)r*+0w(D6i2ljSYd^T>%EW3K_WlXqO;>7Sz`F1U(5l00=POONhtE zV0|aSJOT>j2`@E6bv3~NlTMug^R}V>YiDM`0i6Up9@_rF7~^<@GFR5??Ioxw#LxG{#O1efUd54tigiXTLjgSK3_XokH5`p z0*L^I{PuwI2nc{fr~r?R^`~DMgZ&$z575Uymc7;eyDK1f!1diUz=!ZnAv^zjpB(`_ z1OTK1xQDkN+;`{Du{n4EVcP@%>j+$wus8c>ZRX+Ex|f>|;sQMY=3ecO2jF)p-n$0_kRO|vkK&QeY|!hS8?6Az_RZ*4E?`XRxlsd zZmfg`j0w0kk-QZ%;C!AOPK~5DBoyt2b!xrbp=S`3rcEu7G>9k;ubn zAJ{bS`0sVfzv$?nusu z_5h0~_+9;bAmR{@>gD`N5Z{qM*!@W*XtkbjtWZ!+J11bvm?%&GhS{d-Q3e~>?U z*ZhS3Q)Fat`>ulh1Gj7v49hbkkjFptE?eB}?&fFu^bLCh{3#|!aRS?V6@8^YYG!}h zf1Q2yD}W6H+1X)R5@DRnVJ*IOX+^KcdiaUI{oQss1G6{W;TG)rlM*2&pf$vY0`6E!kfNkt5@Z~a; zmJ9L`d+|;0llG+*iqr4C6na!SCJ}9}9g2yJ+^i5{T%G1kP|4OuR{-yQaM=$k6Y!H| zx06F3N@0+@*aMDmswBbCeO{+G3i&D&7C|cwmh;3K)3Pu=nLJbwIpBb{8d8IWv{Zok zQ1_g|ATys)L-~=TP_HKm()I1ur~oHx4l4w2wH^e`FmkVybH@m@e%H4LAJyputuAzjUAR*&GNA`6e3WHIB@H@`dyi!kT%Ej|ErFD| zIP?=jW&}iMc{U47RIjo=yFEat*UObB1wAhSThOfkWhXXlIP1rwn9dxX?E&}s+Zjzm zmA?mNHs5?q7aczJn;f%Z`VY;z-o;TtLG?Cm8jpRo$6-7aD{K1>ew##fI4Vk~{FvRv z9MH*Cq1kwYCz&AU5mGCS@;BqtBOLS+xI;2|fh>yLf*VJV3T|;cWa!b&|#h!(5m*(;C5gG@HC?8`;EEzB6BHOXUp!QZ6A;US1*a^ zp+4_o2_xMV+-{8D^%w)YLg)$J78Y_gt-d&NujDh2AJkX#=9lpQ1qh7Pm**WD(mpz2 zpdrf;4e@2_>w9EaK0Ek{eeF6l*E-t3+s5znLZNHY$HYLPa++_gw0b{d?Oasx_hYob zVST#4PFc;J@8fNVGL<$m5#NO55N*rmgiE)us*K;JQ<93S2$@a4%_JSyEROx$skt-FGhNibr{DnS#B>l1~=$)sGU__brhGxVp}Y-}!=8wsj33V|4|}#wwf5OBHplpfY`X z;nO99nd9l*;Msrl%bm}6jLkW*bq~)W=zA4yms=p-CSv0l3`6N~v0ONF#_}7r`htu| zdN%}}m!M1K{7w?D&JnBn4VzHa8-u!P=&r?qBEjc+TA!b1l`5^xx&PV=OZ`uU*niIb z0m98E>z{4$yw?8@|+NuL{eeUZppn$V!EyYCjWS#Dx( zIbZj&{~_>Mq5hCMcQGXPOzfobSnWxM1Mz=^wa%>K)`UXd=+6MVZ1Wl=nv|c2r5{zZ zZ>gvqf27#y>f-Ne82k`ri-_pWwGyf8PrZ{@@@8Zldw5!Ks8IuNGMl3ewTb3JE4MU&2!06ZGO2!A*gr-J{=G92sXQd5gm~hB$|1n5lID(Kia&Q-jgX8CSZO~LM8!aS4`Gr_s^JUuQA#i;73SL3=8 zy}bm5Icjfsdzbcaf=IPjf&nQ)k}zLKERd>;R3mcpQFbR+a)Q;8d<}T~Lnp`)s+q3q z-AIx|j%AK)Y}kuxk9{LjLYI*4aJ;cy_<0yNWUdfU0MlwTH{oo%@ClUhI<44Q2P)(g z`P5j#B~)t1nz_kVT)h;B0+78Vo+Vw(4t04h?jDS-ix_u)KW{b|!d@XAz8UlRN}@z& z(d=)S&h9J0niySmdOMg~QSiseT%zHqrLyjiq;iQ@*`O|%M0njB2SY7|7R1v_Qt0OajoQB`TJCm3Cn=&m}38)nJj{RhYa_W7K#e zINW3)_myl95VlkQwHbEKX{yCuXA{SmWC`wpY_H_3_&dBF_4B~Aatf_4Cx#%4u0r%& z@8JxP25Zk#OqB_CHi#78_IlUB^Yb1nYg;yFPo9+PkVeQI+B-)3R7LN4uF@w^E&c_-9Z@ zxh-gc#UW=#jafQKf{2N?-~xN@aZ>R{A|*ge!-lF7wC?Z6gQ7MC%ww91u0)MkN12K6 zL3YUtNttiJ;@N%Px)vDJG*kN zACztqD8!a)Fkhfz2?hC`8-CHVUzhddx6t;;vENqy&FS(KD!PY)&&k_^yfXsr$)F#e z=759lBs9ilyVk!Tv}qg=+9P1rF;#j-_q^AF7h)Y2RRNn)4xn2ERPV3L6T_jj#CusJ z_kWR$0Q3{Y@w|)4Ev|GidrdT%o=H&8KW8sX?%x&Xu+p+~AAvHr9YztHS&-~d337_h z;uTe9XNJo1az8s1lqr96mSQ`aNXGiU8sqZz$)PJO_YcA7Q%%PV3|IZtn*fxRoo#c; zz1b4V{8VW&87@qO^0J;qfHpaZV)xG{pQk@m;mYWWiOYuoeOg_W3wiGs`J6YL%!0GW z%<5;h13nWkd-|!pLnMvCV6e7FXL!&e4Q6&DliTGvYD9RrKyFgyq4Mni8n*&a%DdbZ zS}=O7|Fp{vMte(J^Fcy=GFzG8#I>@lnzQa5P>?1M%WX3{j7x7}+yA&sb%%65(DAb} z#dt&uQa1Q7wJ7q~M|6p%+Op=vtmQ_&avDlT-w&iEI{)!ez^|{yPgb9a!%9}Df=l-= zX)nq*UhNR|(A&MigCy{x+lqN{rw6h0bqXjPyY)291ifMIMElYk=b<3aY`tb0@98cl zg5jGWuWUIApB{d3S3G5joZqnu1Yx)xjHn;hlh~ld zy<}Wh!m*u+Soeur&DHGpfso02bF_)vX4T-`?4-DmbFF zkHwLfq19|fY(&o5y)0SJM&G;bVAEl^6HX>4s)kQz1xN@qi)xc9R!#$mLbMQ^Khj*r zh-L<|v2cRsNEzfp?I|%$JXs$CSJPOI>1KdX)DJtI$xpY6#_%#XtOuG44yO-4-YR%a zf`pz&g2^iK#w6ayh8=57FJrN|=d)St(@y&GHA#pguIV?vvQ~BbvO<&>JJ9VODxQGX z8qbN!Eimz+bki?h`{i060UR>O{95;eO0{o|rc11d*s2_E50s{J(>EB0X>`2H&Ef^~)n|J9+Q zEKi{Pmk94oHkk*1bGRg?#iLO>AP;|Cx*DkqA_IACNrCmA#Ww8CGvCM6r?0^C$~s=> z`Una4>EaQs1!3oYCc7_lpD4^I+#N~hAdnS4VK7jy1wM(g5N~moGxt>6`m8Um)s$2N1oA?LxC5&_Edg7{4M+F85XFI2%kRm(b$ETtSLN%;P5ZT%Z zD$2&tHNa=|@&mTG>!RRpUFyR2cd$%Z1JV1t#+zhdNt;${$c^C+l_o%>P`SapNs^KC zl9`C26n}+vqylJejv0q}RNZJnqhB)UET`n7N5;ynAbut_@F9e1>uZ5s2|W-NLKcXJ zBWnJzUXbP{s5@*Ax6(0&Xg7+Y6_fA*B`Z)uq$#o|R zS5R4Bj*RgYpYK7~u$-EEj2R%C|kURh>*v@MoUtw(8|!45>gsD_1% zbGUHQayxoP>?r&=ie5F-3;M5Hw^hY7D7GZf_kW z5ue7LYxgE$RC;QT$&Oq6$jSll@ZX%f!l8r5Ed;JiQS(DQAN_t#$XM}Q!_PD5jB?uh z>XM|2vuG!ad2^ISRPaP4nx*Hqj=YoC4ed!|6fHOz34S<*mg1DXd}SyX*o&$7}{Z@B>TyLt%6QVF{C$031X^1TO1x<=Bf%7}^z@#9m7&3BQ0 z1(#d=&7i1drxqzRh5lhkBBg2X*Fh>o+l{Mq-XS^l_@lMR5T}Qt;pgEF?{b=a%n5cn z@5JH9L@k36#!K$==u+;9>B0&3e(Z7EHs{EssLc_yWDD<+;BAL=H@G^q_wc8;0gOUw z3lcg2&4*(M5l0JEv=WG8qby@!N(EdscjL6bBt6eo-M5Dk3+{fi$o+LoKhG{Y+GWb0K<@b59(XFia8;++^R<=kTZsW^qzzRp9Eu|c=H7@bzhZ=eeQ~@ z3Bk-hwj_6B1oe70%8$7oRQD1b%_E*9p8+8ry>eoC2!|(w$ky|Lu*x`sc7W^rf}l=mIQ0h3NhwaMy!} zZqW;AawE(Hg2#&E6-cwEUQ(89+0L0w4(7|0u!Nn1usE+)0soT!CR8rJDTZly!@>!B!754;-vGX zk-4>*P52kK`RGKAL-B0mT0u499_tQZeg+B77rkwZg3UsNzs@&Ix?6?$%r2TztD8C! z&IQPwdB>&_r8kC1l?M9@x-}8|`llf$%-^q46<7u(1`)xL=wCPLCP#ey3E>d|Es|9N zwi=UKznquFVSIZ?z$oVOwA*Odw>*Ar%(fXv+yihv292El#(Jzu;BzEIrzITq1eeEW zYO!IaXFKd`u=BrD1_g@$oTOfpUCC~)X-1=<7>_so;ly;y++l^s5NI{MlIkG8uPnRFak~rX^y)+eDvy#8F-d>XUqxv z^Q+suTvkP~Bm(aB@ru<}kJ1x#2LG%t9E*`j4?G9nz~+9g4kyTu$l3AwncGy(V>^k0 zr2?SKwl0mY!FDgt-ZxA`iBg4wH&|*|5f@U+-#GCdz^E%&pdfjPJb3ySZeKnqi% z6yBbLOKjh+kd(KsZmm%rra2v*asj>AS(7+6X$o2*+8`Exa!gR}qr?s^&)aJ*d6`l4 z!^0Xm|94woCo3xab`YF-Q;D54&$y(B!HCrpBZf|0SaihD5iza%S>t%OC^sYzqNWW5IM>fj z?079VC=g(O`OOWxfNz*9;6B=?vz@ug-a=ILV_p_QS3-luSb)J-Go6Blz*$PnOh)K( zWauSy-eHe&ubre1nWY@>9ekK>l3Oz(HhfzxT?a)KlK^;FVQX_P?Q=L0_9hqbPfFiN~@TKwc>hqpgu{ zwdht15m9pf876-?Qs%NrCfH-e^NaS><>ymEbh4O6wd|8U#JXP1Ig8j`@AqLbn9*8Q z$2}Nc#2H>(H#XN-_`D~)Z9F3lN4CEpmd#1LY1Kv1nKVx5Hk@yJOqlSgETd3qYqoI8 zrvrxnC%>u-D)7;Mh}xXTGU=~G%r(fa;Z~)c=2YBa*PuCZ_=?$uwC#l^uYgMw`N5l* z;i=St9@Y@o@1p8Svy~RlUi^|4Wq3Lw?A(~kFc;va;JB3^M!?qFHTA)Sohi}?MNw)f z@EfH+l68zEtQK$XCxq9}ml2~I6&2M*U|+aVf(0Qm(I^b;9=wN}CXLM-fi2Pi6>3Mn zM_m7OAU!IWAdRnG_fu1Ro3P~$?sIh}#Lil`DC!QKB%Vd&mtBD9PpKTm;v4Hj;hozU zY$N1eZz)%K+t8gDRUM&}8}Vll`?~&Qe(e!7ebUy#|4*jwuudmH554OGMuFX3aaDl! zpP~E2%ed1(>JyAei#Xrd26ff(-}yv$5lD{;oW5GQBDe2(9vcWH>cp5IlB{)|l&-aM5?2V(Xe0);<19LjFGIE#oaP7=hL2Jv8dkE} zPE$D!`DXqG{a2TsN$GF}5!s?Y!f4 znlk!|5hWfhulwWsZRO&1z~AsAXqSS(yEwSQS|`CN%hmB^q3@#b{43t)+I;g5R*BaQ ztl6>(tTStWHWxIf@o!*e?_rDPTz-Y#@-2`Ky(*{%GTUEIzj9_N@~v$Hp{-$u2IS7iS`K4e5$hx2I^85kP65`uGLa9CDcyP;f{QXUJ)a4v z7!Sqy-Xioymq*L`$Im}4N3Q;83TmEZ61Qypi#;AJ%v-R*T-R%(RsiT}ZeiutH2GwD z!E@Jn)zK1zMZI0~*aWUso|KNrHj%%~D&3Q7^jqTrTTOg?Met0ltfRDfO6p4&(Vwd% zfQ}vn=pb2l>1|AD@CkZyLUs0>5Ic67CcZP&J~Lj{BW8B>dSZvF^9}(WD=>THcD$1Q zEZVfN(6sRiEtmf=@O$KxjPUuvcY5t44@IO5rBx1AEGEfBW188>QtOQ5@@-~lndCYC z0!$sZg>Di8?q`1ntp$C==ouVvj z{r>v&bpdNzOaIgL&e%BAE^n?-rf~;fe*8&L88o#%i82tw#A-CP4@yYC@*cgx{juGL zwbUnWp|!?C(mrn~O33nJl4ou65dhd#G_pEyL-!d7@l@rJJ%x|qV67tCu|^n}8Wdu> z{X{mjhR5TD-PKHw34lft_mr08^QL%Lu0hfxM4zsqtWUFnuC^8xdR&roDXZ1ih_0!tU!Z{ z0+W>vd3st{f{K~C%da<)6g%XWN6f4W0fa-xBYA}FMkYaTw6n@7R6Om^Fj^bq(+K!( zl9mQSFLuXO@)F7Eiyinjt?a%Roxxjmt%6R*V+dJ<{n5nJ!TnB_+j?g_H$er)Ut*5% zne@hWOeVq^=Y%Mn45T4lSDL|+*t;MGzntzS#fO(zENR;iopR%$D`cWMBXr|id6QS8 zOYtf%hAFDWvQL|?3qEM=GpdOQNHFiaQIh%z>c66UwRiiX9V*UoCC9=fcw|a}&$(!b zg%n5}`uKU3?(~ziwj$0UtUMPxDy#WOW>~W=M#Pa3w&XW)G;5r4Tg!_*OOq2;1t}=% zeM9Gjxhqy=yd-tRot{Ydisi0w>YwFs=3={+IM<0uYMYviab|J(%N9i}H#N*Dy>PhW zFklh0rS|RBHugqJS)N`?52> zTgYDba-8tF>FM;!IBSa^|)&?s9kMmgs(>d z*7u90jtaC={9B9XJmH0{mZ2Tu44VkGEY)cSY*Fc>dLT0;eC$I~w&F(jhF_3rAF^}( zgKL=#{-mqY)*VY>`0?5zJ^*lshpGV0YI zHrZA`@l&L@koo8&Ckb{qECz!>Momq{zj2~mNwVNYMMYAYI7y;{aiTrve?ESGejR&m zud=LHw^zTnULWfiEG``;HwLQuBN!+GGGier5aL$l=NAt_LHzy#;}gUIVuM8x1MDDv zEBg!?fd;n;8Oq)OWDj->Q2t4jen{d{@K|Vh7yEE~s6cnnk&oeFp#DHU1oBq^AuKK2 zJfMf5H4qjzpb7?xHN036{F4jN&^2y?xbUBMSiMGl$h+|HaJz2@$gvK;eWX7~XnDYb z9Ddqy*w%k%fV9)#!J_Wo<)GLkAi)MyvQk$kCnF(`4rV|DH>DaKfx8HxApH>5@Zes- zHbHz6Aj|@^`hM*W`wfB5IR9?_E}RWqA?XlsVELhO2wC;XyB5VlE@8ky5-fr`sVo6& z*65w-j$HU++X4UFAo#_G-tOA@dj7(J`TsaTtgrQHX$i;!pqB9UAnhSQo6wfsk#?Zy zfS@cs7m<#x5QIJgc?6J5<5(B=)UFBq3a$)+pd{{X18&&t!l(zbNAV865=m}n8OHed z12!fGwY2)=gSdBQKhOy5>fjsh`MQ3yYEjWnz@I-cHw5xpT=>J+JlY;Ega~c$_0WTR zqvMFWc9}dGKnTFVKtzOxfb`gb);34{Urk|n0cv;jq`PvA3BkR&)Klnsp(G$Lp=7plgCwNI;f#ykHTp++2!qEuXN&Vn7J@5NROssAG^o zKVM&;v$&i_EevIiv$l`ArBjt(;wmyC;g5isUyI`-y&WKaBUKw8U|_$xI;_9y(pY=H zy9^ryW4p#*`{f|bfxtsQ6&UL!zEm$?o=|H)I>;`4zJ}%lagDGLb>H~T%y~$25bwjU zzdU!nT0g%hU#3aFpJl(c5)t?_Gre$YKP_*+SbkarGkm_81fi>-{#s!0SPpo3zm^tI zKbGFCeJx0cslUq=1b@eZI!T*#W_2;l?vvsE$le&e*PsZC{(x7CBVg9a@YlhWYWXJ}tF{=){IXDBXA)pPOr5sO(>LH73SY5Gc~DN$8Y(s_IX z1uh#xy-#R?SZy99B|NnGA23aqtEpnVDZj-LUF5XE2Hz3=IoDfJ%on+DD5z6NO2r6p z-dKq&7LPc;w&vC5aJoY({4`fYdJy7hbpdYOM=)Psp8j_{1tN*5=vxv7lFnE|e~%V= zJmR=@`J|nu{(2$CgGow$UlQrc-Fprq4(I_C+#ysH3}lK$XJ1U>%-bjHBuvuKNu;n#jo#a>qPtk^O1qPL=0Sr8v1&Au zk;r-9B#@UhK1jp%lQRZZ{g!$4RWDKij%X5L@*R`3$4#!AzRf4v1l$CVhx4X{w($|3 zOy-2dU6fX#3AxGkA)eRwj_sPv$FN|prGrt9q0ruKlp}^Z1aV-?94mL;Xik7S7h!X- zxoZBn4u!03vFcz^df*?a`w;9wKX~{J zrB19uIS&XY>xbOjpy~>GUJstE+^i^Mkms3-W_ri53}w5+6GZ< zhUc_V3`W=`E3c<&aI)Hc9ORkoZjPQey5`!+`92tr2e?)cqRKtqpWCXB>-Z!YTga#i!D()G4{6QnBk0*F&N0XgP~C z_uUx4?*N^A$$-AMoYz?)r8ISq5_;@D+%*aFyY;5dC1dyfpi^cQ_YHebN* zGn%9;ywR#Q9Akmx0p8?Uq?eB?|KLZTqhbwE>aj5br*A^$KaPy!$K}%&rx&Ro+l2#8 z)cL(Rxs75KSoZ9Xf{_fRWa)AIN~T7mGQ28Pf@gx)qIlfB)TU7k6t@-7tc}+{PC$Gts04W z8w9PTimAzd#cUMrOF&N3ys*f_sML#v!3>K2v`DMA} z+g=lfg$eTCX6lZ&-G~>Gzv0Ug#m?LFp1AEToQi?;egY#?{Ym>L3JZ3LZXJ+E$f{uV z$o{CQX_i30wO_i0#fjNfEyR;bgy0zES}DLZq&^=}cl$b+d~5Nl+7;a|tbMQ8MJQB{ zf?@FF2or5LLU-!G0h*{IPZ+Ovj`HcgtTtmc54`tl4w@N_{!^I)K1=pE1P(rl41>wO zhbNu~KJOM4sHvH#c+63B8_n7y$rV(a0JuWg_Bqe=Ca1pFHf^T4R2#{rg&l~~ZL^h{ z#e2{0iop@B5FsVigW0w{RVqbc5idz8`U#2hg#O1`{R#Q|?xmLoe8y{zQ%uE3b-8()IL#qtng4p-kwzf zDB;bQ>=@JsYG6P2O+_gLj`d-7C=jUpz50}dK{vxXC2$8-`-q?XMNTyJ(t)$v{6f`l zb|D3dz+=1m$vK>RK#nvEX8TSjn-ymJ3J0k#=Sq+s%=3zKa^S2Q zt_*$0T-x8`CR`)MzaSf-FwarpQ~%D_UEkVBoRLE+mvhk`&4z*+BjC3lTcPm2W$-}M zzA%gmAo!wBWVgBdmLRr00CJNx8riU{Q626j)ouCGo&=6sXern6wPz)Ryv%4k<10Ig z$YnxoSiS_PQTRNWN1gPA67P8SosSfV3R8Rr6QqZ+;qh2Tynn#`K^W3@(2XL~?};)tG>#@t@7d#0!nKdcKsY zjCw<1v?%IHgAiVi*8b5K36GHMUkilQMWN(6A~xbjb%bMs<~J(&^M0?XB%~PJ%~!&~ zja2<~$IPyLHbA@DbiHhWXs_3#R27mVw*K-6QE89D;)e#>1GtESieMTEZK*@t)e4|s zE!fhgW&t}lDS;<-prp<1(S zxEq?wa1ZGB(XIW(rYF`so=Tvq=jZZdm#v>n`yE6cy|Qj!z&&mdtlYm9@B0=~={r%n7sQQ51f*(DO zd72Cq;6rKeB;M#C-IB)T=}n!fJ+K#Aw%+n$sUqDABw6kGOs|iqh5g}Wy8F)T=AalK z(~eUFer@5lQi&mH7?SY^$}WX0K_-SvkD0f8p}L#v@_I1Jk;r2+Ps?Te$XM&6?00#P zwCTWZ{Da;U>>*EpZYB@%Rj?hsF=`bS2FhBko2%>v_P=>-F!lzQBlld))|>qYv-0+0 zb-&kx*)s?L{A*4=`85>qXPgZ|R-g6yp@+sh=L5Y?YyhB<>5R^T0f(YG|%k>;ROO? z`J~;V?8;I4#z?e?0S!kZkG*xwS8vX@L~rG6cm1zfjE;PP_U?*@SwtT}J`;|d9(l^t zKu<2>(ZG1)*Qa;NlvH^mg7|*R3xWT$?VG3_s(Mg2O7uI3*Ly*yY>!NjsGkfrtxf@R z7p!*;>OQ9a%cOA;2TbVnG}$gdpAG%`5|GDMQ~9s_0UA ziMQ6l6s}~-+i=P@Jzr%7>arvUpM9g`H*)CT>&|fI9+di9O{ysQ7Rw3bK<6-8hpkWT z$=W8K9p6c*D>2xxj7&AqGct~L(O zDK-j-0_^p?yJ8i$*vzApj+%Hyf7hCEgE9O@n_8(G)8y!%u(lxzm+=sSXacqiH_@lK z7u3lqhxZq2>cGa}EQIKk+eYdguVsEaJ))*$%RKW&`~_#?eoZ>_nboLR8pGflGjGam zJ$(vKG1xA+=VLoO%K!L--h6wGcJh(|g~1^R2!gl)B>-tO)}?5-e)~tJ&7Si$=+TPs z&xC=X z8l^v(i-+o2i-7W4r*!T=PH6R3<<#o}L825P7M9-kjt^&;4qkP)i*v#0gb(GNEI%>aoq zJQHCW5#Wn^EE%+RY@nsaTO|Ft{t!ewrYw}t4%8~1ICq~py7Rha{8`;G1?fg4OYJQ^ z2rV@UqRtSf<2#~}pbc{v$|kzGsMOIoxn|0G>395sD*K1aHHSF@*AizY5Q}Uk+5Qjq zAYOu)tQls`=(RXv{T1 ze4TXeQERIKaqmU?QerodBY39&IJ~eXJGsS#Pe7VcASyv8k3+9Qn)0(N)BR2nZdnjm z(6yMz!|6n+ddRy`1y>9Nm7@6ryG#G5&G{L@%l04Gv`o+d2&!>X1A6xtzRJg8PJR1; zp3sgwymBK+M0(_x`Y-A({0#fkrPZ}r{R#o;1vZwHTzXT*GMO=jXo?p+IOY~94eb2| zcE)J;sMIj?c(}vHwMb{(ogX*hG;1mf-v9~TPGE{~H`Rn3l^`j%pvb6-X4g=r3QB!c z6>(ZBKb(`DDBp$;ifJ?H?el;xMPfa6@~-RjD$z%@oX6eW4{;`55jdotHBCz(vNi@q32MeuNp)&-% z1*zuZMMajCc@OJgPKvRyF~vhm%kE_b|7d6B=JthnO(tjhkf718`&5=rEJ&i3=9fod zUmJ0)$^4-`ww2uC<-f*T&+hTI#zJGJ#hwAh%1?^f)XL+G0~4vQ!_KAU|IA@x zCYP3w>u%0o+Dga#18755j>;<_zvnqkNX0_gY&=^u4d~qQwo*o~Y`U%(W%q4rK?*JcI!%nx~6*`#l3o0)t7w}fkMq&Z5hn0pp| zy)XAShCV+-gf1@VQdo(9u(XjcE;92z3_RQ-+D&3f!Rb+MbDWLz8LH^6k${gdzcH@s zz{4yz2&`CyY@qi(@jLjGzeRQC;Zx1EKf8UtUzO%7P>YVj_Jp-&z#GEBd6HhH(R8E^ zblTW+%TtjeU-B951eI;zQ~vkjUGhKcxfP8qyI}e+z=n8D;<~{4-}fTchI5y@>)dH| z*`UaAVwfJc82T|e7A2z}AQmj0T6#+AP!`9GB*#@!nYj_7uV=%X6TW42gSfNfx^9!d!@Qp!kOo!!^XOXU%jwEDO>_=l) zRy<*$3b^>@XyC0gr?impmT+}CB(4t_;%n3>@Z?)6GTs2^gKZyxgZ?iRuQkm1cqs{4 zweQhnJ6l>Q!dxe&R^JI-qO_P2#W^42{Gi<<=|}298N7y;SzCJELf-RfExzwUh7gY{ zz?Lw09mGwyci}8DVc3ifaFwrgZh}=Fk@nn;y38b%_UGcdnJwIUb~3>wA42s2_}x9` zqQvZ_@O$sus~AgvHe)NfMfwm1<1boL!W9T=QS#HmJZ=8L3Z!9~CZz7m<-F6SRg?n_ z0FL|C5;+>82=uAAZqWEx;o36QPVyDUvE;!H*WGWW!tW@7rG=@4VeVf zJH;)TaOmgFAZ4$7i4$LUCtps(Hjn!bTY*;Eo?@lmixQw)XtW^xQrLCSyp3R>I#+N~ zZ=;AFQT7-dLX7d%-=_mzDd`@ZEEr0UYmp;&6k-fwjm!gStsS8*T*!C5;|AZ2#CfQp zE~|ky*;om+0nakI)$C(?Yu0}@jInd`0zEQA1IJL@e&nV`G z`3-LG^>YPYG*E80gWa6RK@LNPSxB}0Cr6dYBE%dHcMYS01}%4~X0^}%>ND|xVM-bq zef~qe%(?@(SQ}DhrzE*A(*Q;;Sj{#|G?I3U@ZTqweVyhCj=;e|)MRc9{BL)mLy>JK zK8^927-aG^gz4OWJRelfr~epC>%NaCVl*`vsv#x)8k)iJ*ec{Lu=YzJFoJy$OHD6Gs(cCFMTXg@YIx*5kA+B^bn$ ztohAi9jW@sSEhl%T$UWWU}`}ME#@G^cEmDly{{$I5ts=XZqqN|!E4kKDo--VV_hD7 zEq0$l%Sy}mhUI~*L&UE#Lbk?=ezPzazzTx~1~40|na3xsaERX)vk1{FU%kd`>a(tz zkl5znfnLm>n@yX#TX>iekxHh2eX%X&V$>!BDZl-tr1?%%9_%9JP;S2As!Nikv&j1; z0xT(7LnC*;7z`NTDOK`H=M@L7Q9^ZT(7ZLO|{_|#80-$kC%rUgH;q&tP#BP(+AIjy9kV{nL zeD=4a>>kua@q&h=)rcOIfDHQYjDc77+pO<3hUTVQk7gSorpa<;)URV`Dr$?%~>{^eM zt!evc&w5ibB#y8S$t-iUN}IjuRX=#-qpTfwg~2iRM`e|1sf`K{2y>rEZF)GUrinlM zO04Zhlk=!W1!1RH83IWOWBAZKh+*1M=-zkQ$QqZk&~i=_wtvFtSR{P)D{LxZ%adY> z;7q!CM}PslNRi})yg}yZu8#@kG8ge$h0DNV+(0ceVgahTG?yV^Jb?d9pf7B{YYqaw3pY-Tb{2Vij_yZjG_WmYv-vT0hy|@iH}6trc&JM^6#3Y z)kx;npP`2~B^;{tjLmtR(=;W+orfZnV7IV*2G=&)GRi1VicIJylz((ZdU^|RlhX*M z$J%#BK8NSJlCQE)Vr>y`0ccEce6iNqV`i)MMa6CkG_0_$P4a$0rE2lVl@|xI<+en7kfYKc%LA!CniBi3Y!`mm)5L%|44*3o7i~c9=0nkC zeFRZEfJdL=;GdsdeZ7^CixGrK>~l>9CTE~(B*2|(786-60t5Oz2dhjey(MFp)zlXB zG^#pU@H9IJc`)=n@NI<0{w!2G+d@K@5iA??)yk4_kr;+6T3{H1-e}z@ZqF8Q3YG}2epHqMnHTN$O zCOv=bT?1Czcw1=FktJ3j&Yp=F&$P1B4rb(eKINVn^vAhGvyw*tWGcBH-Fw(2_0e?AN>)bRp%6CUTLu~;CQ3hIN2`f&zG490>XEb@GWQaQJ_tqc) z*_Bn>A`vs}4zG3tl8&DjC%mh!nig8eMD{b053?11{z=5D9TbGm7LCOvPsAvLXq zQ<+A}MlDQ=Hnnr5y~Z;8h5XO|Fm?{XqQDHAz2>{NZQHhO+qP}nw(+iQ+qP|E-b_{Z z^x|K1cBw2=StL2%`9?^rw4da?rsq_$s_oghQ9ebJkw)z`$(xg^J(#}O5t3H4LqkLL zH%f^1geAU(h9PC z!{n<&;|ObMEfmOfB45G4np9a%9ZY&?RP#n3%)cDBA+x_CaM?vKj#!6yer1N8bX0( znl(=G*o`oL@(jX|-$Nb%qcaoM=NyW$X#xTixS^w(0*z_P^A683`Q~IeyR`M4qFF#w_=rrdyQF%$*6O~lM6<`U#iO#Y zzT9A6bh1&?=-PfDLW75kNc?(JsN*1bBQ2bTC$FE!Dh&IZ2Hd>oZArS2I2QHd!8*yX zMOQ1J=Fu=Co=A>SGzLAKUw`x6B@jncaM?L56g7Aau)*{ZAtI{BGN8fsp%H zqK7W$>&SRtk@)9)Kn7SymwuxlyteK*mvpAJZ*fic-7MO||868vlq78$Z(SjsT8~^h zAOlsp{oV#`FH7+W24}-!fgN$DoW**DVMqBwo{UsUXBj>7TmH-okbe!IgtBw@v zlAJek1b+bE3Cb$;0$b(Dp-B87E+T)~>$_ko-ho6|6HA_uqZc>BqE zTA;>EPLoGR!bYMoP!rudQyt}>S?D#J<8^-?@AYv}7-qivmK_yo4}s+-2Mh9w!l&!)o#zSH6RcX3qrNnpsN3c}!l%U;J#QDsMW%EGmF!Y!= z#&a!R1Z=rCPu^5xyZ{i!{jc?7%RqUgD7csOaX5O!OXY^3*QC%+hd8f*0ng-u@@VlI1@jmJDnRtp6XeWT0na`)}g%ACdWAEBFiy%yXZ-${%bE z<>~;o1>nmTBOj;{{C63XijszZ67%4rOmJ}?@dD5h5I7gq72c^n=<;t=RuJeK=v_8W zK1CgfybBQ5mqqnc86eYM-5?-V^^fPr9oVE-xK7~+Ax!FwkRG#eSK z4S4upEOp%rx-2t<3qD3FdgQ+8nbFDdQ5XO&;J)0G73*Fka}SPyUwI(Es64N`M+Zk| zAa&kWz?UHPz&t*AA8mmfeSoE5n5)xAyJ0^fWqf#jK!z}&sXkSB@Fl-OzNr3Gzk}2F zPJV7cu&dc8V4yX>-XC8^Pt){}qM)2rz7xObbQwiOL0!qr^SabuRY`GnPatn~b`Ah) z?5!&Rd@eLR|JV2a+up_4f7Yyj}m_S?}M$azh}9vQ(G_Zm<~QCCwY|dmyZ(yzvxGH ze|&W-e`|#{`nTo}USAyS9|8DjY4Pd)Ns#!6Z2jTxJY;D4a{cPD`bIAHAbeZ_xnHlq z>z$nizIn`XaRIW1?B?;p)3EwV-{1~F>nVPN-T=O0Cbep2taKQ+I5Wb(l8@i5}Q+u_H0_ncB#e*1jXvRi4iiCwc=}JuC!=Cd0tr}U2)0{c4vKN9y_5tY$}n0zv8k0v zM#km{&NY&*iKn-+QHCiqjs^0g8)WJtgCA{nMixS5ZJA7>&{kQXOQr%)N;C!z7N4Wu zjq|V=FGQwb(*?JgA)x{s(+JR6{@p)$krkk;2xK&+cUNVA^OAVZ?kJ7jQ3N|xJU=ig z9g`u(-dtpR%=x*dMVnvR=puAa{Tkxnb|M&}rPam@Rgo{+g=8MeM>jAr@N@=oiEraz zmF?j+xQZZy45grB6D1r7mM^RS{cNP@-S}pQ92${EQMp<(D0h#?yKWXc+ID;SS__Nh zEsR>(WEx@sbKmz6jk;zH_FG<_4HM|J(F?lwukR=WygvDUdD4Z`t9%r~`PWRTgl z-D>rz;IRW6%o}56Ta(bl>We@J&~q(28~r9en)5o%x<*edUh=ulr>h+|iq_MU_)InX zvIxh}!LX|}bJhE=B-E{3fVC0LNk$Aq;tuZ1=4#J#?xv_D(MxQJZ}ZOf%hqm7YW<-h zHYh-{M~Yat0zrdtwNAoPa}`$*g4(|(Nk~+B6iU$L*R%i-yfBh@~qhxCDWOJYHANe4z9|MUP{k3|?Km=dSG1#W5( z;Dmo4)O@EodXAb1N!rH{d?hUAj0E3}UyjTJ{YV8$l^Q+xu$cpvTx+Fd-eb^RTWQ!n z2T{+y=I&#nt1JnH#3doGD?mp*%EY24IyX2t5~wJ8tC)_Kw}uG5m(sR(H8BHN?Jfdq zD0K;6fTle;oscW}drEm$8jelvFg|#mg5;)Q&em)cXELAk-MejTnqRBIIe2Act~@v_Z0)^9Ge(`;uN0oGOX-J-J0jXwr@{Z(+z|nu_Z_Z5o+Hi@w&=eG9K|5U~Lp8S7WB z-(0(&R}!-`X&?VO9hW=Xt^m<&ly3lm(6mKHHcK+3wS%U+-E80MW>AeV)zU!ys|^_t zTZpO{y&tIug-e7|=%S4hx##0PVp@#cQg0 zOV&w)FxcZwRsI~IoXJxfb#^I)vpRXai$S;9(fhvBK|zQa-r2ZWsB-7Abl({&wzAa% zV974R+V+T?a*a*WcG0}mkA`Z4=h@|It9F(eH|9;PB_QKdQrvxbg8PYV z6QftKNLetfhGzvtn?RmTPHY5M(a6M5|4}kLDbPj)KP2ck;x1L)s)D=@i8DYUzJg57 zutXsX`}3Y;c=P~;V;kC`I{#(A3xe{jc(l4kM>C4Ck0{Ex726QuRhQ_0tR~wQ&YZEK zWSrmVU+S-I>k`YB4J6!tU0fvi(a6Nxw@K!N<8c7Sj_ZkpW^%D9ZeA|J&wuBcGU0$8 zmcRkhE9k{w|!Kej*ygYewg^-e+h z&XpfA6wh0n%!nT^M)Qg4iFUtM+BuSZ1(ftcOVllG+(d^Q@uj+ivhikw`ASyAH)Ip% z^Fzk4nnp_zM~CMXA$EG!eC}QIrW_6tl;Ml&?i-x07A#7c&?nmoQ!egChBSMnW*}9 zk@#~$n*XQT5S3!U63Gdn4H6Iu%lyzvf`cH+c!!V7@g?ZkInYR?_=VKfz8o8Z*O?a| zJ4Twd?m6s{B+fmK@M8Atd+w=1^Q5p%temI|cOrHzISF)Tmq@d`oKk$5#ibCqK*nxYD&}a z5Bd~XyHJ@=VH!S%FqEaS&~0KEoVxX2CuD*JR!#`s_P#ObJ>z;+qsrKYLF(4D+QK@w zzN=x`kBnPMEaZwI(SZYcWwEvyuMDRWIV*+!Ua#H!in3>ifW@c&?!Ec(eiC&o9SyNo z%FoPas#;#?Cw!*E`hu2-K`ys_F+*_*Y4*x^QaI!_OSU%Kj~Qw!J}A;&Xwjc^{m`vo zf>)W7;VwvYsgDv;lI3ZXvkjm#2?lyX6(K$9rRH_ABz0eevOE%id^c#`R?9H5T-daU+L zutHLu(hpM?l0`N|`(wM*MZ8=IW}bTeP1oMbDJqt-EFTA%d6P#QMf1q7u(W) zghLs{k+@~kH7ME{Z`Jgh+0=Jmn! zcA1C3xwy@f<`}mg;xK%AO%hjjWOc+)F?iP%!*lHY>q}ryFnFGS_=Pg?QLy4W5JM{8 zyI%Aj{a-gqgpkZ?!9R4`Sqpqc%0uz;9TUaG%MRU;Gpx%MH@*Db4#|1p@AhClNws6- z4R|bO=gYu%;i`GhPhj?4Tdy335uT1gsO(4*n9_Uvh%fQAd>8M}gn{!v13)Q9tqT%r zB@+{(n!^m%h_}f1h06nMEw2O`ug%vicx)LbQ1hkB_^CZ`@G&W64Kp0x0fik5!2j_oIXX59gPFNp1%md#Hky3C*fI~%}x zwv9dvuMa+A+|k~`sBQ9s#PImMR{**)yU1#5}#wc~Sy#I32fuT@0Z zUn8^n8APcgbF)zD@<)jDS{HXobp^*n1ctbEr|M&?bN$WF+%RwbvDlDGziJ#<%hKW` zjbF<;VK5)~+64Oyt}#tk`trJGQonRWQ)`-gMfms1iQjfdJZdmA0z}g z+@|GHTw2l2W%xC(j1e1ZC^?Q_<4goYz5!Y4X7_D{IP!yK(@&3jj*-|sXFTerX{xv4 z)$Vq=>E+jbDt?Yo!K?7(e1c8BjmZ>{nzU+)M=Jd}b4EKaT8}0Nbt^>{x$IU_pX-Qj z*Up>A-}S8HOvwoSVvry6Y6{Dy`-Ln)Vjk_ zW%6_3d@6_-(D5)3C>uV#J?Op4Wm(@I=l0Rx5tSlc}MEm5ERIXzu zmBfKNb3+uZc|J{og5K`_91aQ<{W&E%z?x`IikzC+^`ifoWHW1qbZ<{O%-~fCz()LY zNWV2BL6JvI<669^{JM5;-}wL+(7xmq76!+Bk_k9kyrrxn;h}R?p`fQaBv`Sq@#R(` zf1-O2S=dX%ZRgQpA3`?E#%l@RlE_UZX$`53*3HGP`yh%K&B7pg<9hG+(@LGDjW-VV z9l~nw&_|>(PGyC%n&H4EO6l)GMldDk6!K(rlpao+)sRDWf8o2d0s0t8i5`NeP2^60 zJ7T!EC@GJU~pu=h81qE7aEcB;sQx)?P(jt7J!ckN%`>MQ7wqjV*`NLAB@L^zZ z(%fmD-fTK$aQ)}A$Q<|bRB^cF(@G$(imFDo7Qec_=L_!sm{R0lHd!m2r)5+t2vsZh z`(b5afT;f%p+r8fmqAfE*@l)|(rXk>5gGOh=s2&Fk)B zX$7KbJ5b8~M`VE$S3>ifp`ML;s8vhOricIZ8~(fCbz~}`JMQzd4G@Lg=;tVo+KC#y zVroPpk(e1tp#1s^Ov?2J0gc1P!viZ&dU)G{l;Pw0qm?uf&HkYB{mI3k)+jZm>B)*O zr?go0xSZn*o>4u!a1L4S8;fw-m6oF-c)OTx2~KGt;XJM+7$nOE6Kr(zmM!i0^@d&h zek^K()i1JDJ!G8JPkA0Yf)Vc|{dc+fC~y$7rDw1cAH$5ALZKeVXU?Cj>n4%jDAP4I z&FEBHYSy4>C#wR8bXtX5+`x{M4}m7n1*mlUi=QcWn%yrVEY7C#r0!jqqPp#en9`@U zPCPS5W_8LLLF39$d@w-Js2+Lnr2TAY9oXqhM6a`cgaf@G1!1MB4^-ZRC{{JAdYX-! z@hH9T>?l&!HH<*V)5c88mh>cl#+iYlJOTYMJ`H(%|CypX7vH#jI__XQ;9%cO1gBcOW%!tDC4`yx|mP8n&eNZm> z7E?9V3QApkXYo;Z+(X*Bn8CEx_a_%5vgEwm0H-Xl6lnH7WT;q8H}a|$t_euUQ{F?F zkl#DpTdrEGUE!3`p{`{^`x9@n!b)BwTqcf79CGW|R&!NB^J9A=Z{HZx@muR9T4W=Vo5duHw9rXp3_8iXG?i9yilL; zMumdJi_rM%lADT7>1nyerQJV6hgGRA-6@01u=wSO1N^F zl-4E55DCg%@a93UKbC2ww*tqDQ#oRI@>ATcml?zFj;z zzzm|XcFA#n&F*G44G|@8;h7Jn({S7(+VdOt9eA{wyZySc$>s3V_>Bkw1o|A*HFHSn z5v8EA5nH9~c=#vmOQzQ%GNr?j7oC*bI1^(t+c#||rNPK?3{$gi=rNXnid^5871N+b zifjY#F=V)y_5#qbF@%+DV4kII GagC|@)ta)gIj7U%wF8#gy^XmDKS9qaY&Z#)4nPESfu(Cx&M-MO>zkYJ=5o;6`{spZ4(+PaQO@vDljAdOiVRtPH9pIF zE+&L}BNdf}N@D^ zYTq8lR}*Tnb=5hhO|TZ=v#+}K=E!qV$&9kwMN_KT(T?_F>TY=1uJ03n9Xp@1DyvX- zslgc1f6ArR)bK30iho0#2UDhGk~gfiak~%@gUh-!ZqWr|r)Vb4DL)j1MB9Oktnl|7 z3>GZOZpJER9Zir{0B;aV!@SVLEfka%GTvky?$Ag1A(yKLF-k-V>tam#uUH(0*k=h+ zZthVpln1(*eK+g9Pbp?;9_2i0d^7LXMk(s9j_+>A>5dk%@pC@qI8RnQM1@_QtFl5E zfiHn_@amPNU@dfGLLZ20ERRPTOVEA$5jXuqZ0R8uA!-S}1&_bPO%gkO2QS zR$Mguo!D42zSx^{m{?D{jdwy;;tw)y)pRcybbH=#8OD_=&A3zZG*OaB7GY z1`@#jo=iqdoo%P#R5Fa(;ee2lEWP)8!ZH2@rfxm`1A50i@%=&Kq zKEhgOneI;Jx78~%eM0sp_8N}L3HkKqpnBrFif-e%ngtR%-NkD(m6A!lo2W}vn6Bp= zo5;Zby>d;1Jdb+?6%no*xkZ!5;Q~PD z93<#H=~|vA5|`%bt}^d7@Ga1_EnHHWIvU56Xj9~Z*G)>j>notDt_4%R^WEdB69&J2 z&nLw9!#3yaV^5>EWPu?R2lJ5E!ti?9*SlerISo9L=AkU8VU!JfGi~ugZbQoOt%p=Q zSB`=>kh@M|!YC7|ENvaKD3da?ofsgUdD#c*N#%mN2Z(KnU9CtD3JD%8Mib`X4R+!) z3_YC;zlCYUn6(V2eZ?nc6D)v59&ty?s9{yBR<{H^nFvP+T}@)sl)|;k1D1VstC)V7 zBu?q`Px-_xxjY~H@)j+yUY>7OTWZ-Bca`cbznV(QrZjt=SRkHr9JVff}%r7BF*h#yT5f6kGT#d*6w2vir2M_ z#x5F_oKzlpMoa~3!lH+O zf-ih9HqobiUYL?;OOBq8k!e^F5!G@?{~W^CdQ!O&!GN9&rseMVlg&2xGc zcYb~|ms-+PI9f^wHOI2~U#_%~P2BM~g>!?+PF4gkBMVBzs3w{^xO1^!_;(%&Fvp>| z2n>jmrDoooTh&@u9{l$zE#Oz8O=IdrX`|lKSK%@ zI%f9glpb#9S}5+^5%^w7iGMsFeC~i$x`~<=gu&{WQ`eQu_>6 zg{|h3cH5rKJ7`c#GO38qEsWxP*D@M=5tK+Hwt7!_$=-VZl zyVMzZz+)n4;D%Ru==&yyhwchyTO9jHLOtnzAiBa&sa6-(Qup@xvBA?T&UBH*3(Z+7 z*)ZW$nRMbXeie>I=1QO3QGo?8DK-b7l#vUQ?Um-X9wJ?Eh0!C38#a~m+%vuHR1I>X z3Q9WL1Ox2)TZZb8Ud>iKhVLtHH-_-G^Hd^!ad+F=&41&zV_ym(3lPLdkF=|m1$9TFBi5y_Pt+SeQHza+}c)p`C zAjO@jLF)}h8pkFe8j82E)U6e6#OLhBQzsgQrjw;@=nRRikP^uUB|H-j#{rhVnxTh_ zvgR87k<8s4yWF|x7BE|}B0L;{kjt(TXt3#~%)T{V+Z_F!qVH;^(FmW$<5iWaB7=gd zF-{?8HRW#SA|W1aMN-#l>UO={|2nccm??!%e5H+>tA&Mz4+^_@AMcSSjk+*-cuq+v z9M3H{Hz%?dGg*77aKb?xwdo;kO($#T$;0a5fQ+fs`|PQi8|Y}pGJ3IUuXYn?`M~i> z)B~!NFeKISiZa)qbW)p0j<^3_dg99hg6}sLcS_MihT-$A`&cRX%^f)_+sNh)1vav} zIUW^$OT2MtZsNvn9?!CZ@_vZoD6T47)K5=kzL>;B_oM}PNa0lDNCgL>}3 z=oo+_V#4^^I9>lC?4$t)S#?MI?$>pY@`I_Js z$Yf`@b_p}>eas9DLT4UHLNcMkpJkOYyvean*TrG8#j`R!(xi7nG5J|HTpQDvmd3lZ zz+|W3d}pur`{fBXW7aRJJV9Az=|4vq;En$86^rek*S0jcbp*N5JWuyIu_;*4K~(n* z6zEzj5}i4GIYw{Hk>g}%aGle|wKb0R2q#Uih9RlPJ`_v-yQKOL=@uh~@&_s7qce)l z^q-RG@BSCW(`ME`4%!(4z%i|Qi~G3gM9A~jilr3XrfeIjA#Jp;*FP0ryxrF91^|8s zsMHIs7?JVJ4Ci7SBPKU36>VtD2v0W4ZKFMfp|U+rp$wpNj}yU)TNCBy#-%RDmWmp& z<`c}{A*+{hC_212>I^ z8E2yn;Og-B79o6|kl~FLi`C6tQn4HYAW;&&%d3U1o?MS)nD*Hp&(aKRHgcR*Bi`lh z!7p1cyfP;u{K3)2Ro!$<5|TfBSuaBX24MCp&1VB2X(L?C)N(UeGORv~;e|a9yR%km z_B^^XujQ+ST*4q-ck3Q9mSUV3<4C~+gXPkM#S7d76`4#nzJ|7j0~*HY z2;HjA?3pns!Sti<0vU)VD=f%BY+m_2i_mN}I?2R5*XrEP`0CQiMFxcnq%`_YKK04N z`nVxO+1gX=qR`FiU>|&ooHUgF?MsR8^!xG=0j$HH)SG_0#0|>ImT?}x+m1Q!(BI+j zO_Dnn^x_+D$EwO%FRi|uV9eGHM>be+4`su74l^oOIcfPeT%zX z)&46c$oEm_!ICpQ>Oq&pV)*rql8zTErdye)KxVmM?*@JVDmNFIE0|d&gY^7_ptYyi z(~lVzblOB^PLieiYsQx}2yiLmiNq7qZb*SgUBr{`(a3QP7Vij~Oyb{ehPQ(fsVMUI z{U|V4@O^^i4e7a3n%G%yH$AaaL%fYo&>uFh_b3^ z;hRImn6wOVagi4B>ef6dmLxd#J)?Xw4#Uu!tA7scF9e3G8B0>_SVVfqRMK@M?f;vbwnzu8#P&Ja)lc2Z(YZVx{9i|19O% z3kpQ#|W0K!%xZ~*!`gP!n zNnk1F+V3kn&I1&&S$>f8Dq?!f4#w=6>|2s%{DR$Xnh5-uX?5lq)hMG4jk3x#1ftp_ zu6pUF)xm%wHheDO64v4}VKA)&A~w9PkEZO-BJBD!C%L64-J(WRZqJ?#(M0LS%`bEA z0xL`ee31}d!gsMK6I4sa44+FpGx1_xWUwqcQ%J#O5B3PG;pW(w01pUXMm*I3G3oiJ zq`i>x0!S)e0ZIR58(~TNcs8+%!KVLg%3fMP-GI7 zvI7G013W{t-%m&Zl8v7DK0D>u`s1keGkT*E+z`BgT=_YUGJ@%eFdbA%ww0`M7^%Bw|rUsHLE=HEO;*Y?Y2yJQs0fTBn z@FfMvmmp9x6SS@4M=0qbkS>Sbdds;8G>2X_X$nrFwQ*6}+`*_McV$lqQr(*0Mwb(% z7D4v;{0Ms;BnunVK;?Ut-Wu#zM1PXoSm9+hg8%#mi*yRL%!r~SQa0q#;Eet_(e(EN z@;NxcE9Go~SqoCnxdS=D^9s?^4Bw}oouU>~w-weJ;c)w18pE*ZU&J9?qMdg@^LjuKvatz3D|*kJ!=9`|1pYy*$vtF4u|0dWb3Z-;=pRsL*%G5enEtN2uJs< zD4ooz=u`~Xgr)5r=WoQzwm9W(78GYnW8a{Cc_u|dr4?bwOYRa*r3zNrn0I>fk_x{v za^OVCCE{CZpXUf8eQ|HDQ|+zGLa;JIX45Nr&%hGZi4?;{eNGwzg;o9wS-Z8=SNJ=4 zLFaX8#Fj`1F!TCDENolTvJ<#0V?gmq6mq6NBbj9rg?=TFXYH`R1d?Lq>WMf|wbbdb zO+ste0WBT2nf@N|GwN}2FEyer%vd)s5J;~1)V7WJIYDV3j^`$o?hKaPj(Mx>{k>q| z;fg(U@ad%IqonPSqB$j19eQG1#PZ9F7Q8kqn-0lm(j4_V4dK{>5P}KEYQY{PlYcSXlo&Ahqm6x@(PRX)QcvLU{-(lw91g#!t2Q)&rxU zwHKT8zFtpn^(yN`hPj|^n2CCE0=DD9oWQ^Zh}0y)+!~&O?1gCtiBsLv{YoWYOFCnU z>XHfEW=J1gqli(mEtRH(ap;MVVkpDIT8JRttZtGv);P*VFMwXLdR#j}JUc2XSxL{Y zWmnb+fImicQDsO$15WQpALV8>kymq>aHYM4zT2RS;A%{-aF+K%xvzijrR-4vMvKz! zjDv10?7jlEE!47h#irtbD>+}fM+n>JafpxRt*6s4El>YY zANV%PI(H-S;!UjZsOJ92lhRCFe7tU{P6L@@?zL;@cQy6E>%`!yw&H>w(2ZV&4h>CF zX16Q@sL}BRv%J*E0?(f(3+)`u#mQo2YLz||z9-J7#$L^pOyZDt02(|CqxGZfuP>cR zb|Lo-3NONfTD+aVW^yaRdHiEEN={+z@Rvc3g1Gy2>%FDfjQ%t`#CV7>=$MaYC>h)%p+ciq zsX7Qtkn=f?Si#2iAq@7qa(K9w!=4S9VL5*G*a=k{s#WH_hIdF$eakAfUEI>zVNxRk zI-ki?Q+TOHf!J2^lNLe#KBf47DBuzb+hT}+Ce*KYL)AxV&_+4%ak*C&4|8p7C~G~J zDxm@!F!0=79aA$@iX{hs5k@b!r160}Mo8fmsFYfL7_>1nm0a>sd#?-xR0VWRF%jCX zOOpmTR_NlV+1$IA*@~FC+VL4f?R1= zOvQ8?^Zm*B$G)6)Ke`r7DoK#I@1BZ;td9kqsFm>;5WO22{LMY=BWc8_DVb)ph}tg# zoe{e;%lqj}+pX+`Zd>GWM1`HtN$_@sLUP0q}M~MFM3#V20My2s`^^s^B4c{&RW9R z*REiAc8b{8k6Nv)T#=2->=&+CL!bOVQPph! ziK=F1CngxlmXcX-d;zh1kaK2|=vna#dVFFXIY2iht3l%DDA%xQ9?-v(dO9z8J&4FVB( z%*wJ73Wy)y7aw9MY<9{TK%|5J$Muj2O8_2Mo?ZHi58wd;0zKk^!v7!LM2Zb2|L6>O z_Wg3AARt z4%k&#IH29T2-sK)5Ax3}3v3>k5DTxi6x*VY=Fhu@3MKIIQv{L~OoVt&Ix={8eGLQB z=?Sn80Z!pc>(7RK4lx(x&JV8(&(&8K0H~?2HkLQ;|272xELJ{>*UP(wdk!PY4?rFU zy@U$%$Zz64aD@*6VCm%FQwheu2?O*Ayz&OT2lVB`3ZRRB`*Tl9 z04`*G{TFj!W-(?I9?a!6xSa9}Mxg!f_u9!HA21Lf!N3;*9^e4h|80%);fvC4?-J}C z=ji)bR0jU+7R(KJttiwVMDUuRoX^`2t{x4)$A66dy zr?;wT3;vUj_2L0R9?zcxVwgu4;B58QPc4<)bG_eyw&yqWw?_{b1&Ib!hG>Ql>DNwL z7WM}C?i3Bo{t+@z-WdfR6ru<<;J3OEIP_;5^lZ1HlHQBmAML43Yl-2z%BZdvvhSsp zeGTxJx)fBb0ToF9lWm-aKM-GQDeUz(>!Mfb$L`Os%JHwr!>_IQ_~P)fTl%%z*Dpkn zP62I?AFzD!vv46uKBU+V0;Ki{@Bzs6#xk2*S!!= zay~CS7Y_Nt$~~OP&l`-N#55>W&{-c(e(w&dGAhKA9z$}Eb&kSq7+av z-F+I2!1#Hd5BY%gzH6`ZC>c2j01>>tp7+vn5w(CnADv{rD}3JW6xbbrfju!LsDCC0 zygr=R-fxGg0s=tXG~KFQ6dEzaUcgTn1<0Pm2b>am-{IHhml#}2E(A#B`0kPb%NyP2 zs}MlI8^87aY3Y8;!9NF+feqSnBlFJIWf9_97zP@t_f}DeYTKCZ@I6`8_{VzP$?|0K ziKlx?bv9?y(H5O!s%g)sUsX}vD+>EzsoI8Peyc=w50_A$^gW;75WCDmaH?50sTi4R z;F-u`K@7>aKbg(xT-B^JVxQ(FPu9Wo!(B{by{3EC$|u~iovwvEHzLc%XJwdm3kJP9 z+Lyp^=I1gCfiukvA*T*il7h~`H;Hef8_K!l?_M8}2AqxA6%$Kc{BzMLf;gkdeSjDg z5W9*f^!pH7JBe;*#_P9DGTzwL#&as&-!h#g%N%xJuJvZ)J^R~ni{gv^ZK?%%S>MbI zG`@6drbOj$o^ittLd2G*xiGgTAxzfj;X98nP5x|aA*92KS~`K#wEH%ffWgNZiP^5d z4;e|o4U9#@<0W461_t*r1RE2r*0n;$knD7qJ9lWRDA~LuQ4(%(eX$wg!B;kRJ;NeX zX>zsg*cei^7+lYiq-YS>0U9$mx7@9e2UH#kOK$fRrCpt$Io6bcq2Gs*ch4?;ZCN1= zZQlMb6I$`RZhe7nHMIW#x}ZsVL(%P&4*dxO0u6ZB0xxBZZo+N2-vNrZ`70F=)$a;C z9obuQ)U%+7`7Z52A(^d%CDxsLnr>tEmmzFFt>KcHBx-&Qoo=*N_IIH~ryJ5^l2i_8 zijn?uE@*SLlc00B;dx7w=p^4`_3QJ)VmF~?#;<)V+M>jF1Jh(lx(e6EJd?Ok?z%~D zPV#X?#)+XxPm1GZkFuw&KctaO1vO=ERKcc@9rCRctRFrVG&}dy=O|Ul2r?YzykB=m zG6Q27{p7qdS=y@JTi6lk48vr@K4=#W8I=JY!4fcl-riDTXhBT(Oj{&~e4lAIR%kuS zD61lhgu)?R#&uqYQ|nn9cjt-ia&*xv~__;*(plmQF8g-Qsh{zk-DU`_LUh)ZQd%pM`3%PDu3X-N$> zi^oSit~m$tNKI^(JZ+E|-ioO!43?FexQ4x%-QJBfl+bQKin8mDls7ZA<#~4!QO#9A z&HVLs>uJw1L=h#gi}aOwa_O-$rnXOlqE;7;8y@!AYFi@Oc}O~OP$>NJwtH1s75G?;0OgY(%8@nDx8Mr_6FsYoDA?hu#Vp$gJxF7brSJi(T3?%r z59jq35C#@xvsZ2?dmbpd4NaEv`B+2dL#_N zP8g!fl%Zzq`gM-e!L%1;3CpYagnLmIcYSgCoT7I39JC;ZHS?8WGAlw1?;078O~ey? z7y8tbW^}&awBQ#C15%LPsIr#TN1LBA!`FntpOp zWw=64RhP0RePDytv~)&FIjGrND6yk-@P6v==!dPgCb392Rb7`)9FXL!h(w;f3705{ z>@h=53Ih!KEwomcuTto+eqdLKx^D##MRHx%l6! z8QSm@cvD~A6VeOp<7)vUS}T3W5)l>Ro-xKfZIBKmgEE~uU#8KzID{H`;_xy}-c6C# z#aC}DnuSV^yayFIbH825UU(SVtZ0AA3IawwM6RCLA#z0A>G|}2e54PC4Q&oWj8)`o zXPDx#@Yyev+EhQ(C5U~JvhMWcW(zW0O%63{PpU1X$Wu|bXa&o*JL&WBdpeJ%9EW?`G)HB(tsD+k2wSLHPml_w8pherLKRT?^eXv29cL7R*Dby_#%Y#VMHUwmJk6fPGk)g<3N#}PV^es3MDumi6R?9Ro99xMd@>#NdZsK*LMvf>ftPfI%1p@;f5|`Y zg$Mr~G@xdYEmRjD6fs0LWlk+4?EXtewlt;_j0;Zp+t6-^-M^jVF5}c2V~HH_ZTDjR zY_{P=pBLbW&S|}55{Rz4RGlz?uBj`$6m|h+{YL#5 z(@fl{{4{`I5?7CNAi2o$9g;8^P;N_@8$ZofW~&}nlwBEL=D03g&FkFaZS?u{E&MuG zt7k{*eOYPL;z74>^h>RJ+)=YsX?VX$0XKOGoq`!X>*TeUSKJaPiW#BK>E@W@AHHG2 zE8iH}#)BuH=dwX7r~4H_T7*cW;7Gi=k;$ZaRwCrOMaymhFt*q);M*z2f(bE~YDYCC za7Y!9*bg}fzZOBhy-9IRa#ZJc3iRKPuecwdxKzR-7^b`RjA0Hm90xL}#zG}lv@2)( zTJBjcw0qG$4BObg$eT!wCJnZ2hPjV!!CfSWt1|?{0UANi}zn}UaoF&qNLHa14y&ycIVPEOlNPq zq;D~r!Q{z1cHIrSs_!8Xm))MDTNq@U^`7es3%2)uV?ot)(s3OjG82l;n|kG4g;LNl zv7O>gPJgE&r8X8{FvW-#?cf#cqY&Pt$^+npbcmQkQZ3;b|FAy&d5&lMpgIg9;KX=bZLG z7xHl*4*(s^?(Z8|W$GMZ1%#^}y3H`u^DLcJJbr~8d^a4K=3PWfn6t2hFoVZWSVS}R zR32XqkDhwiMuD|G*epL_>aEqDJe~YB;lt-C#6X-eAZ$M!et=@V#i|0{t!nkBB8`HC z+4UjUGSfjU=*9uzRHNZO9d6pJI<4e9rA}!(oejG8py$tL)E5{ZjZ2pxa;-|9hNEo{ zrf_5#R>K61LNm5)%ocB;8r@pN$85cN!ug@fJfYgvJW6%&Bj2s|7gD^Sgv{|XHp;XT zpiv6^IaN8YgADzY9Vg-Zo(k5G&|6%zKFciy3Vz3(nc}O8VV<-p zZOpo?SSwY6q9Qc$Bq+61vo+?Hp)~dPVdr@9Xl1`@K<3C5&J3#a>qavPYVHRVh5NRN z6ET}y(JHbe*xSB8mR z!WCf_MD~=UN>wwJ?h#Js>1gkY$@)Kx-9wNjO4Oj?vTfT|m)T|8wr$(CtuEX6%C>FW z#@ty<#7xA$n0>A?cX>`cZ|7C5FSdC}3e&K!qrrB%5yiNK`uc4xIfB>T4&bd*>xvm% z8Km54QpAsOq?l@TQCy*E5*PsGihkdz4I)(K3mWXMIaO!=m=#75)7gA|vZJZ!f?6aH z;8QXP_kzZ__KSp!{l`@*q3Abq-rwc9XKqphV+1izb8%)D?Z`#ON&nh@W0rl=1C^bv z)X0u?RkHy8y1_Gs@n6Fsi|!}1GP?=HO`8hB?xU)#q3PxXHx^x~Zq)?0ll2b}cYD+z z2Od%+?O{KKeB;;}lvnOXRwBk*y;ou762w1nvYRvaoMD7I4YO?e3oFjObvmBI4msXX zy?^_Ly)JwgIe+gqU!i;lWfKl;Y7wR4M@}3Fn-pYYvX8gdxQ`|7&Tpc5-KbR|#D zKQ6YiI>wZYneDX#b$)>dYaTJ#+05-zEyKX`obvO4<+|=xhS<2zb~3I-Xvoq%#^@gi zgYtdSk@H&ZeD07}NB<-uXH$s85BG(%1ROfIkc%`K8sq5zR6|F9)ACHJ2?fRR1xY_2 z);f6xq6>Nb?>(CP>+Ry>O-sX=@mn8R`sL+c#>{lDA0M9hqaQ|P-toR{L7lG1b|V5r zEt8zLZxIRizKO(WZ*E}@f8EM9*#GF$UE2PQ*-rM_6JYx)307&6im0Fb76Kc}Id=N% z%KlIgXFRSVzY<|WqZzBjOn4UZbBvz7++ehEgAaY;u5m3T=^paZl=ENKOBce;P8FSi zj&cw=A!KPK4J?N%rzdYoAE#g!I<>8x7-RkF$X7ATB+g-_O zeB|6yx;0jcCTcx4l#JAgx9lyym{V&t`J9BBClA{TH&}T4Lc7w1pgO2+FOS@%1uj4) z_Hw>BE=AtFGv;c8zVT;ac?uyd>T$N&Rh{;ga7)H!H>Zyg-QskEBhMQkdgkX~H*L~4 zG!bcp&&%z|ear%)kHPwiUj$)!&g%8tX{3}UL*~t|O z?-y%=8^7vn{?8;zzK3<)LrIyyJa25xGqi&umniv}GqSV781Ch8n!^bLI)CfTTj_={ zDWa1pHB~7H*Z$0nlv3Q>4=rHTxSz1Xegc+`iP1N!?m4E5ItEe2g$<0pRmqMV?mfY` zQQvE>nSPp7|M^BfXHFcfg8+NW-B}~5V1k@!+L|KMUYj3i5_*4H4FBsZk@9FJZ$xmT zoTvQ3;#WEcyh&a0q<8xzxjg@fhSoEWzlta&k|Xts0_O^2ZI|C5_t09dk3{P&hg;Sz zqzMX1lF|;&kZO6(dX=I!0B<*;b~ar~p|KB~x*+({p(Bh_{b?D0N=jIEQ?X97Ip5j1 zsiXhBkth80Q~f_c{T(Cw{F>WFDoZE%6l_Vil?nK&_;^KmtUYvhqB`bfB|GBi2_-s*bQB_?)e~f1QKFQ$g z%okp*lGvzY+M3#u%hTcaiwoRY^2^w+B;XSh6(TcZB*LDYXFbSzX#WGnpzciCIN7=u zNU`9Q_T_5-&!>g>YHD8S9}HDh;@mXAl8uA6JI|K5 z@v;!Kn5>T0{ddR*Gna5U42w}BTW7tHoQ90XAsaSzE!Yp9;llXdY(_7?26^uDptU{h z4STL)gugTRIT@uqbEJk7AUo=@7*ay;>L!u6)mo)HJ>zKi&790@Cy)0E6hjj}*p#Zi(k}p-^tU^J`^=im>m7|Y)+K98i}xTvdh*uu zNxz+IIzMIob*)~e=BaBPwxsLa3fmJWNu{K_-3)*KKytM#KWdPsfCoLgq6*vro}Zhp z)lgftf3!c@UD4w7w<`ROq*94`z3~~J@;xKNE=V>3G}xfG%+&e%hIl2w^%x6Pw<`0k z;__~ZVzwsc}kEN9-q6?`?`Mo^ac;9CFqN7w8eD>mV};rL1}JGW%CD zn4dD7vM!NURCXs2g>(PSqh09le$GedF1@ighCK|OoStkAec~|DIW603=s-|_4nte} z3-uY)4d#FYXm`Sr!O=-WM2Jk*&id$8(3UL-vKaR)duL(FLz5MXrq5r}ZN|p^m*XI^ z$CP>1CSqjO17WA>LgZ6h#AW8REIlOPsLPvsqzUS)=5w+~%ALis;k)RXGd(4;aO{en zy|PH&8)`?21s9RJr(+x);Ysd!_v&KDETyov=-tw60vgF&yOCsex3$7d=Wfb4uY{=h zY)m`?O`Q0VJIncGuPC4BKY=)-E|V+}>ckB#A0P&pY7}HB(jR?tNgTpRh?G(tJt*#| zdP~IQC-c*6QIuR?OnM;2){$|?#budOdQ>-he`eoFRtTuwelEd}j=YYTdzajo>06t& zA}w$U{vIv)Z1+x%N^@*QDISGKkW69DB34w%*crWUkx^7r0%42Fee3Iq&BAzI(j7_P?ulO27NDB zGgyr82F@kjqQxzhALdcrvIErnMsY{n!_=155RvmgGY@gtU@0BC(!qG~jVsD<`N0em zH?MN(ZBZyTa4FSuxoBbKTa{)3}I~F%ZYR7*|I$)2dL;@(J~!ubqfp-<;+>iIO!B- zlZr=P$dyqxtnhK_gY{=y*Y_CNc$CB>mU{?=92!i1GDSp=IPm%uCvly+o=%Lz-FJ{x zAxooNLoO1(goxoGeZS=poZ3O&7>r#o#pbDn~LoRYDdMF~Wr7zc4?4uO6X1*1xt zjne)+KTTZ=%?Q~`0oiRYZ#rrd02{OBb~q|2+4o@dg*?PSe4-0G8k+o=SDysiaaIRga*&$9pj+nQ z1c_afWy&@A3U1|`{8zKudurZU5u;<0mbN%*=+juxt>qTOGvJ`2HBmvIYfPv-Ee{q8 z*+nIQK)^DccGL1xGHS=28EibaVrGpdHcRrVR_XTognp~KJL}ST{E2*bj37T~wtvEj z?Zi6hB2Etmna^iCU^y}OiV!eP9DL0;!LM-i9i7>pSJQ-zacCStxOVV088f*j;#u%k z-J+;xFh}wx=9kYpMss*IJSQdCC1{XPtc3dd2Od9ifOW<|^?a&N)gY^ zM5y$_x%S5u*wkddh9j3DwqdUUa%j(Dhl=7K?yQ z?r+SNHH^;=#qB_D>h~t&LjU2nj%oia+PvfFE-EkGXwu&DYOD#;{E%=>2eD^+X=?sw z`_YT8e7)b*4YAOJS*9;MHt=$D`R5P%=ebuL+3Xw|sOlc32&c|Z&o@-zY*N-%(}o}a z4vMpjOI+g15Vnw0{jKS|4C*4qn^=5f@v`;%IwoqWjsW?BTmrsL#YbPg`{+8usaPuh8T|bTMASQ^r&oaXo_Mq88yLRIm zm!nsvK1_u{An!fBC9LfAR}E0A(@MSCxHLkTQBapS-xtAgLK3bELup9hIHnLd!y?$& z2((>{Cd~lHf}uX|^x(84dIpqj_FfPdR>)cm7FITxHE!Fk|KjZS_Zh-xbaQSth1UcB zU_J@;KZFXN*ArH_%h^};e!tC4{j5tj?vD{4l5Z+3sByLHHKWR1EqFf9V>++> zd}3^c>gw#Fxng0to^K6eGz)l+O?~+}(H{j5{ehTx7=8YyQ8?HCGz$Oo|1?~gnE%I7 zI5QIy2lM}L!?hV)MduuaJ_aI)2Mjv4tBa>!H&_}pmTiR-%-x-`9YUI@y$do(*de{3 z|2Q$TgVp`!x9)l8qD3xWx23AL^1}_Eh6UY~g4x+yxuBU3YhY+(Y63AqK_%rFxW3Ve zsj0D%R8i3~fT*<(FeRa)B}i$Wz?bn0fI^WIL>-HkT>yI+P;Q0{W?V#v=)OjI6OQw z{3698GJ|vh$;=D@j-o)KE!dunG^1z*a`k3KLOQswLu(FFLy7nXZ0Gth)3&a=>x@3wDG=U&^mv0g(038zmFatF(Hv8n+)}IHU2KM=bWoKlrZ*pY> z@Ch172Y`=ZKq;iD8HBY9V*yhbJno91YMXzid!VYLCe%cp!|umV$O0`GRRSfaL;PCJ zu1`T90XdqvL9GASB_6wHrBh1>PLp3%)-q@;dDKN$V}7&U_q0czLq^yKtd2No0un%ka=I(GMhM}*uX zlxy8RNk{PM#=F7?!eEpI@)gABOBWzxG)Gk@0y;PXdAk3w9|a(z;Nte-nLq$%fY1vW zl=wFSG6FID57H;yK{`O6H1wNCAq>91KR>7UMD%@vt}zg5961qvGtV7-BGFY}jsW6lN8yMD-l zHUMeC2zR$8QZI~^;2;*i$Q}H&m{seO!Pmc<7ycn%ztmsuX}{THzimX8nA)2HTh0D& zzXEosJP9?U`XQL}oq~E8g7ZJ7@O{71%Md>u%~68R3DMiXUZ%tpjL}38tv<-CsJN7@ zw5R!Q2~BKc_!hMwK^dCg)R_X;SpfBE3^0hwHJ)HUe{H=Y4b9)t*G7FacE(-AQ%v2T za~4NGP4+Ru)i+#F{gv}wSBb#st7-pRd>%}WzM=8)A<*;V3w8uuVB55vR@*8py>78h}h?2s5$@sbgSxL*j}>6cU-3)GAED3#GZEnxYl%! z)88P*`vieKK$ywN!O;`Tut4)SOaJelK(C5m0nZ$qrQyns4AIz!v%;lpELI}!;!8Wx zm*hq)0?(pHAu&mbyw!vSpAa99wPLT1S7EyB#$2bc`O$lWx+U`I_Y3+gdA5!pd7_dgUYEaW5?i|_K7H4mCP#; zVUX#}-jbap-^V(jt@6~uL>WpT!9z(oP|I4A?-q!J(mIH&_1!YNhS8IA=d$zUX(P7g zFP4M@?_p|)o7W<@?PyRgpPGbe0w$5)Q2*ggV(w!sYWUZ?Kkub41OA#fNl%^`Kr6qh z);8#)6&5p_#RJZnYH9~on>#RU0Vfa*2_N_wvA-;b&v+H(6y9*_ddO7w`k0+tzv(M#`hs3Fk;Yd(zlB`7c1DOk*~ z1g0>kljbf>Ac!W{L`vE|zvk0WTkmhgPL2W`y&`b@OCD zkkN!C>)}uCE32HTZTJ5=_6cLMEo~2SMPDtDSr1%Hdv8*g!&|(s)1lqDJr9gs`|`12lJKV$J{Q0iZ;PI-Gx zCvYWnkLj;t9A(#qlY%@4WFGUGP!hFQjx};xTcY^81Xz zHaRuJk3Gtwu9GxQr4W#q5NiI*@H;`O`@0QW>}xquLeTNCv5`~Ck>-I|rQigrUCzV4 zB)Jk;+qV@*(SpD>kv@j)!qSyMu3xg}R1aS$V!i!eQDx5WtRI%or#t7eYGSo$lwyj- z#Ea3`6v_P)t8C4fUr6`R%#g5M_4g+_(fdRF`0L}ApuoG+m~uK;vTw_ zInjXJ0sr0s9)K%6-Dkbrfy+z}*;iA>efCO^!6!bt1@6z&vPY29U>PF(%b4`BJD6yafBf}*Es{aZ{j4cl=f;y zag~-VS&AclYS!9|kOthJDv);qy{Yw6;-}?MMa>TloA-jSpEO5NG#M`iPxS!cLB!2I zlyiUX7@|Hg!9+wA3qGgK#p!YQ5^;SoRIYDa@QqpY(3t8q=bdfsB-OOlJ73me|HN~5j0qNZ#fYvi@{a^`fvCbKSc@(oWAT;R^IjRj+Gx}H0aG^kL4 ziqX=}MEDtr(JWirf{D%0k;Nu0&(p&wH%SHjD8z2q_cA2_Cwu+*N7|1y^EVP-TFT2x zcrJ{kpK|)ojvji5J<7)Zr1Ao9GyAr}Wk4%^R+}C&jHj4cMjUk{bluyWV_>W0 zSmee)L_WJ5fk+|*MV0-hDqGP$)h2_Gr2b^|$m5xdF!zGUTEM6*Qnf18##!;3!6=P~ zgi`@r0;JtyN&t;7i9FP?1gA=ha*Fd1*Og<_Ct|ZKem-{l+?Iczhs6OsCv5b7H4W=v zhMz4QCMB!-(6wc9dVcUUX_azz&+_c3LFWO_&?FiWG(#|fg6Lm&YZxfyg2q}5owk77 z#$Y6tvT10f{3ytOQ1F-l+}sm1W8HqZ(*)oA+DLdFXHuspyLG%>bhpITZRL9 z-CRR9H?Un!2?@S~YdMko$qeNOZ(cM*C-@DT!LD=fciYVDYHt6@Z< zb2}vNn-)@4ErmLfJ^Q6F%&W|kc)`;)fV6@4FfMadMw&Nb5%TZw{0O||c=VTD_sX4t zFr(2wJDMe^>K(Ay4cu(8wUGky5LQ6bR}-DVoTO7iKaMfZ5+cG=Z+D)vuxfps1#4qA5NWikuc8E zS9Rk?SzxAHCssGiKw+>5K3D6&5$a`UOH{D+?}F0^pdXT?$yRcCyEUlVxRTs|EJFSP9iDrK&>kdY#`5DKKXjwC4L;_d~T+3y5YziQ3`SxA7;`S~82Iw|G{$ zI~q=4ngCTPU+Kem(lz3QqQsu|`D_Waj6t>vWjN2L+*FEa7`t#S5fo3pq`FbLjoZP# zk{}tcU+Z59!$^6rQ(J+nu+WwGjLQMHnV&*uxqvu(aUJ;WbbE6+s5BV|Qdlrj*p{b# zw@dzJ=qwAzx(!Mf@54XvQX^4tH$gM7I3{`&x%4xYJ4OS zg;26OmRnQU_xIcGigC|5u#$EZ9rR6$#Cs2YrC>%;HEYqOGsvTC>MMX?!wee-UJ})D zA;jL^Krp`dFgA3Eav|~oy|!q#&2hN#f9=49aXtl|PPZY{IE0O(Y_I)(wA{$0Z;e_f zUqIac%v-ctF|y-eP^IWbLn__J8SO@WlWa~3_$vi>mU<+ZPTXtTrg(UgaA z=w`YynKkt=aID%L*!AvO$5E2#E z-VHCygsu4n0%fYFx}Rs|!JzW^yZHp#hMKpwP62S3{edfti>Es?(*qmjvtV%*uH>&E zC|0Ti?KCGPKCM)g%kYZj)#2T{`V-ixIifRkoZU9a->Z}Kv+0(UMO~w|`1#Ol6XnAG zUH%y1LZcp`B16}jv6CSDHquPl)avcCJLC$FMp`waTBUW?WRd;2G#9sW?2%MgD2(#l z(i$-N2Nemg1s>jdQ&P+K0$J)xGPcStqX(Yw`HpvV88e55;l(o-Sg$;sdDj>8Mwi`- z+9v~TEl2@Bn<(Y26!=knL}q3q+x33r)8Ruok?mXllXTS91b4xeHTfK)rTZYZ2?Msj zXOg_xMM1xEaa^@{^`8u-DD(#&HVT|7PWy1LZAU`d>qm7zc*Px{I5fBoK_{g!{gIiN zLrpt}{X+v$2=~I;57JdKM>WRdth9YXnnvPzb9F>AkiOgl6PG) z^G2V!Uv4JJ#R$QivulrbcZmJa+*RX$F=mr71qultFt}s_;7#gMYsyF~4db9xYB8#z zMprcS@z^@yq%p@uXfenU{nB9iAkE zFd-booIKs%FW|EP7)KRAtW>ftLbHQMIOs7Fvdluhqmp6pxXJ}X@sgq~@l+t!y%D3% z+0s&@rZ;Ot+use|hj!SH+B|};r9#-CwPQ4o<$h}zoZG=(S?IU_XKZwj(24*kr>a72 zDyrf`BCB4=ACC8FD%Kawtn7+ciVOkbZ9G`YMufr zYV`&8gbf-}n(-&_hw+mYNeJhd#yV+oe$jNema{jCUI;eXJ2b);Cd0P{>Fy$}`l_S< z{oWZp9`9h6F!f*{V`Z*wPsIxcM;R(Q%h%wF{&TR>_;!f_%_%Z4Xn-JIE&D<4rmJRe}_iAD`*Sj~{QZ}JE~;TymMan)mes=7X& ztU51Wh4o?SiOae=ZIk&_u&FQ`_NzH5Pts3>-IcI$uiSR%n7EbL4s2E%yTNg{&%Uq% z$4j0^-6s%eT{u%OKNj=yk`R1Ra24nNlD+P%)x=tkNSSYpXB7}+>p}lElbIl#Ihwpf+dA&Tmb{Je`%5Htm z6RoU$M+R^Rn>w!OQmnK`h^%7V2_ig;#BMq(MP>Q7K19tvIx-^zMEd=jk< zF7CsZFBIHg#OCxzLr5X+RjhyLt}S@kk1`)b3{IN|S$fGGMN~+!Xew+H58I4GBa8kC@D$Ot_bf&kO zL!aj+M(0CU2bTjTeSE34H#v_`3+fqGt;cQ>G+b@Vk3}9EqG+Q_Tt-j{?&@tV?UsZ8UBZ!I|aBTlni&6=#p=VfTlJ-Nka`{$S}kMtU7g z-4GXAbiF}cB{B3nA=lzRuz}h4MX|H?6P>OEgtxtnyH^oS{<6x~y(Z$A1^>mP+(^XT zpHiT}GB4!C->16|VoZa=jk=mk^tVMlp4q?pS8^)a#Yg%WQkpk7%lO6L2~UA6epMn|G> zbMh~mj766!FrUj6?5)@SE3V>mzfDpg_^NS`m~>u`~5y1hxcI{ZhhzNd}Gj5U(G>XM5q1aE^)|O1K^qW}5FY4VY|!CNNzruc#BL5SAG>x$JrK z`_NodWc|)g{gJ6!sS7v+#wJCz>~dnU)TkSN4p+%6Wu{$vvT@i(xLpro`Eg|u1Xv~? zp@^rz97Uo)PrldE)X4G0L;_`a-obwoK&K!`X;}vncVg(86suM~jN0b~(m$smb56I9}EaB2@K-*rMp37OFQ{flWUU?`ys~>>@w`#vzH;{GTsj>qhjQ>eA-hf{y zhc0qCahR^A!V)*XPxQkJDc+j02r;;jDks>nuYpE+=fRIy`1owL_7496zf-o0G<4{> zM#=5t>rp9cWJiNNrHvz1BfxTorZq$zLcfxImT&AIgk0(8 z3xH8Pz2BEu%$sI~mn#LjMNdCn2S?DcQc%=XZ8Z*?-NVUYX-lS87MG~yc1=%SKeOlR zd7=E@9)EdW-e1Ez=x=5MxgJQ`3&Zf)+2+ARb$Qbyh#1Dinr!QeFr}~2C^zm4-XTy0 zg{&pjp|wpv^2~bit!FiDj%|!U$Ne_jkRmrWSoGm=a6_VR1-{QU2(FhrioNSD--KzL zn7q;zPKNH315Iz(10qbsw~DvoGGvDfawpc8<;Eg>r~54U@#+Rsyy4YnXj$U3{6=|%3zz1E;Ckg<>Un#y6jJ%Fhm$2cxh$h@tY(sJ6xuB<&ev7dcVx5OJ_mxVg$kxag2wO(~!fE3jZB zJhY`aZawyUKA>Xw;eL)_Y`dS;HoyaZES@pPoUl|5Csq7X;F7(;4RHeXLbg zPHRhG9%r0qa}}EUhLQr~^f1o{-$YiR~Ci zkGb3nilZzZnb9I!3As~x90W33#BIIW2QA)ARYWM-`#l%IbWvL~=W$Z;A3)@7N9_eP zJlpa{YOox26W)QX)Koig(gklHBqYMbKl=^79I1E_4@X7ov0M@g8~*-m+cO=GKGCh|iz@?};}KNA1*@pD zp7>{ki3E5`f8_1Pg>ItZiHh!`sNUuenOB!ir_vtH42b!IBT6a}78b93bl9$(Wew1+liVO8wmJMz$HBO1 zB*fop{&>V{69gg#0hiJVnOO1HCTK6>wfad5ofI;yNx{=Dc@k+hWB>?$CJD5huzS;> zMl}H8oa=thsHXeRWzXuwS{iB1hH?^*w(d#&NpI(wmCoGw#knN+KgQjis6WtRH!{i`<^Y1w=|{jSX2>h)s^$K@oxH!kU|J*JY`z>Wy)HX5AwsJ zOGmvUFTf<{UX5SMxUEd7h8(oE===;QOz-^(VN*_G13R}o31pH{se1}d|6aG2=U&1H z2CJ3#?F+u;XefSxCvB*zOK`Ke2}+w(+jF5k!ak5QrcIk(Q$X37w@#L7eR#A73y!?Y zUz3b#<*N7ZiHeZHEfC@@pp1ZsCSt^mcrF4hvoeeX*raknmJG>k? zEFRXP_>_GkF;B{lMHmnvLb=Whlxrhw4Imp)?HoaWkW4Nk0{@i zxSB;KylM^oiMh_=Qm8|l?uwFq;F1zL7ZmfsETS<(QpF8}A3LZseC1FH&aIo4{n=20 ztzClfJjcp3mWRCxP&99%<5f>d8YZ;2N9PRV5}y#$r65AUX4;;j+l1_7nY4yx^b@St zO!#P-Ok5{Sfn}25rVp?WgL9zJ;6V4GPt?}+LFyug`zOE>zIA7@-?<***SUT)bx`6< zng0h})4yLkMM3=2GBF6-mQy0?;jF7O1@ky@#L-+q*dMI9s6feQuFOqB>B7lU;3f+p zwx)(!&-W7IAEh{+4hqgUyd^jK811b_=*MNV+GGG@Z(L)=LQ@K7fMi{yYZRwGuv}6d zDm(MJ+b$(t?xQ0!FB7akmzXIX^syM*bJ!_nS2y`HJ9ESF7jj#*F3c}*Cfl7^OPDt; zz1Jq(iqpFuXo~l6*1xGWV)I6g?lU|Cf?dO9G>jY{WAwIrV@>nSq{8$9*sY^;TXMPbsK5u@MQOHg2c}^n@3%8hDH2EdZUE(CCTV12rm|S8LseuK*ICi)@nCBxm3M7 zC#)S}eI&iPBW}Ii)0Y?or>8$q@=RY=0zTX0b->36mS*zVy>+cRy46T|#;*lKcI9p% zZXeC|7~)_iqtjWudt(v^f>1jiM|V1VbUsZYV74?VKmQzl67~^Ba_h|{fu)xIqYV-i zbCAMIbK8NoF*^EN6h=_ji~fB>BDbnyycdGFOnU$DDsJgp8yz}6xd!@qUtuX0iWvd7 zMtkqPjMV=t$wdxh#~Jr_Qf#af)_r*b7654PhCuuD>8UVbcy3+ANEV~k*NY{`a_pyY z=$vyhbXD;2rY}Kt>%z~SSP=cg>LW;gwg%oVo^1Lc3UAVy7AUwQ_jdN)7QesJY2#V{ zB!5L*IDQw4hY$-Aq7_9>jmGorEHe}ZO6rdnx&v&C$S0^4s5&CQuouLW$?YnMkBX<$% zp_BE5qZ9DM7!7oP?AW57OI$?EKL{}=2sZ6@{EE!hZ0suOYPp2RR&zQa!+}_&HA}CO zU|Vkd>oM^GwF1Wa5Di8z*KDhSH=;)rRQb&z~| zo(We!4T_7&yT#3^fbElgT9+TAE$TRMTe`pwk2VI%Aw>lY5> zpcA-@PWs2sD#q|}yoa{7&i#6>){ZiSW^$(op{|eCUY%YZ=OjQtb(o2GEN!nZ~To~hx?AfXQ7@I`)=1w&plHeXD!5n zT&?cFCGgb zTr)~?sm0FhN)B`z&V3(a4Z0D-TA;t1-3651)#ExruAzY(rS>^mCHFl`-EhkyzVlHD zhMyOK6QOj40PYo<#nzWyRUTZLHdtSRBId8kac@Teuha%^?_+G1MJ4%AD}M9+a^dk< z##1&*;oijFFj^^k&zJa*&7V)k+O*jhMl7u6?a0DbWY%&R?Y@x=VJhd zFAZ^$ft3=Fuxe?7^y=)tuPm7;DDd7)vQA9w1vG^>GZUJP2wG}_^1mLKVS zuT|e!DRi2SH!tNPC&}Np(gp5_;CE>YJ`H$lw+`r+CF8Ce+oP6G@S!Fs9N`mw*jCIt z+*@ha5%CT~hr)eQy{|Uo0XGxI=c~?^8+^Z^s0rmuJ|80uk0ZS4F+Hs$%0atM&2}(K zJum-FN#e8e|O)8t3JHy

<_?B*Nvcx;NJVGpxgxLA_W!l4-Yq14Bc0-ji0d}2+u!vyc}>;f zWI)4Q$!IBbR;p*%L|NnmGLWf#bq22pPX15|KO|X~rA|6HcuR!He+uvpl}7##>wGNC z|HC>T3;Un{s~5_`%EH0+f1sQHo3>$L3`$PY?;IKLMMXQ3CTRH zJh0jSI}{q63*R>~GCnXe5-1^CV|sZ5^d%l6Q3LAY+62x8{bfjW4#VaQIaxBb)$cYz zL>Uki4jPb)+BZYmH$&Su0JOAq5#ANyp2>rE;Pem+q%Mj zv&Z)Ph#_b$glKSjdTRPHiBEI`<4qad^kb_e|SvQK{GWOY1Tf@RGgiL_H7pQ@`;V;LQ zzzzUpo%{RP#>^1d$%Wndp~1BgLSvm92)L3(itc9TMh1wLa#BCc48e}59*|j{SreSe zwYJB2Vg`im=o*0C-seBz+~m;W>gI0j*yQ@AN^)7pw8tRLqbU`HhaV_+V;2EVIJBjt}9!q{n}x;cAKcX0eap>OnAp;p$sJf_{lVIx;;$fNyFE`hWle z=)a;7S64vN+OX~cTyq;M(D&{x^;j0q91w`R%PY7BeGof*Za|xL0RLU=z|~2VqocjY z&9A!m#!3q*+H+~@-^`D+kN5R@%3x_R!8;Q zM*h1SV#14u_oKALzi%~AMt||UKKGra z=31}-_f{Y6dpZnMZ_aO7id!R)<_|YBf*nCXW>r-tB8kVC!4UkNG30I$`P^q6IYfOU zXW&*p1CWC!Fc575?Ll4Sg9E6>uz%!_7%z}oFkxFahuCE&oZb-_&1UfnS{ScS2~)RmRBT z!`l!*TGa9bB9t8T7e25K+MNLQ8dqOOzqQ$k*`xOwz(fjIUI zyYYjJ8sjf)H={rI$N~GJAGF)w;h!1ItMfYs!CwCZ8g%$;HVRIV92?&RKX;A@TYnY* zWwXa}{S&a4xb_R&Z~N86<`9qnO9j6L*iG!{ua(=I{1Qg2#ed3%Tf=@L{L_wgx@+aY zWPS&_dMxOap8~suXAX(jCg2oA&H!+SnCcq_ zJwj+^bAOZ9lB?Z~`c2LJC7kvjz5+mej%uv+>;B}XePV)m{V+q=)py{&F~2Y>I|$h! z_}gLd@U-XcLif!=s=4E;?-9bn*kyEKo*_ayz{Lv?dAQ~I3o<#@3A`X&U4KJ@g}=Uo z2H_rlX5(=tG0r{Ts{FpkwA?v>&yIZ8l@qvo@7U6pN zhv@R#vEIp&&B;yNw=GQ^`Mlu)*SXs*$53J&&Na|;#@z=-!`%$U17eERzB#k%(sHUh z5|bsAOl&CN&|?Ng;M+AWr0ceqmav&~%M0os)YH9WK^>ELxy2XR%Ocv{$=8H*n!v1g z8%%1#aUoMFBWrQfm9xq6hSd=FpVw9II0lyn`_poe0n12!W83m2bvEPdcBOv@ORd>M zMjflp8=#UeUDaf2+_kP=HCGFfnC}2zAKo`o;d zDh|Om85f0=wT9Fzg%UrVom@XRH5r3JYTGP)N%aKs z?awlUKZ$C(^}uUvsA}V0t$MMOB&z$uWhveNp~3tjssrSVn*dgIRup5b3uE_D{UN6! z<(loEv@VHUpHI#-Pa6QWi3SOsQNZtplmBC9rPKh{DNu>CyV^B6J#$ih;V`b=U70i~ zXWgjmA7M3KjLIjoOK*W7u46=cXnCj66A?CD`u)$EhP(xF#xf~SYO9ST@MEE2&_b$T z@M6!3B)_0e1LiFb_33^*_}t1i7o@TEGg|1S^)BhT6pCEZY3|e65EPLtt+vpV-bOCa2v}_m0DY0xOgdfTTv8j30UHGgAvXy`XudPjQ_N*R$1DEzRqJ9-WRG7V0 zW!3)zKS030%Mu+SFcrPzO*_IxG8xT>F-YyYIJkY#cs z-&R<6`my#A=ku;bEFs$(N!5k2!ku!S9@~e}L{C4SHT-w8hPV9yDAzofkxU9s0^u9z zcR5<$^b}c^74Z*8=zE#)WWOl-nMF(LOUUMSB9fB$EYYFHDAGpubEvXS>!jE4$g5FN zIXoQPe`sM&!CN=z!9SV-j*Z0L4iUl=D2~q2a8O&nGq3fHx=|P<$YAmS1uB2w7{K>k z^+?XhkDB3O$ZTgQMH%cvshWD>?;bB-6CEg0e1~g6kN@_3`%)8zLFES=7kqc1@qB#U2U$c?`=8%A-?c1 zZSpqV=u?OMqm9aa2rluKIHvI;qv9ISK?wb;Rj4C6riqg(`7RxUniFbH$6+ zZgLz1Yy7_UAkk5_&A*0ml7UU8fRBZE4-wAir!fyo#^@c;!lT^?^am*; znPAOMr|V*@JrgH&qWEkp@4xT_SLN3mcixz}=aRvTsj?pxu;xI>oRhu##OXsynXzSo zrmQ?SDLbhDv|<45_~E6^cOp(E2o?d;q4KVZqEA7j2KZ`TMbq7Tl7~cA5Ag=*mvD9G3k~rB_qI-nXwx@l6cIU+Y9;;0;~=RL`$P z(NcT4@(jzrLj-lgD94e+A*5QJ6L()nM{vHN zV=Q_a6$P_Kl|?mo-Il3?kFRQ$H0-!PGQv7f*id*~j6!DpUQy;&tHAu>eNvZBNP+{M zgLO@B&Z7CZ>i8A%mi@}_Y2UvZZam$YajCQ8)r|%Ms`xiubV^#vMoR$6ZpQXM3f(Ld zvYb$TlX~Ids*CoD1!jqra(xMm5-`pxU6Eo+3M<1rRiwINm1TMPspOSxpJ`IW=dFo0 zoE&(3Afprz5@l4IE`$^jc8=7>id7TD#qqy*My3RXvUg4VK-go^I*C3U_9Acpt!#j z5j=3L`9ts`70o#S|xJ z$Bi2Q9RIO?yc>TMB(3RIH7Uxm>!R+RfXcg)<6*bytD$$zWMZ&ZVaVCWB)TgRG#p%B zm=zAbNV`-s9J;4i4PGk|pO01f&0mUkC{#=Hu)d7x_A|&}8m+LFn)+16sn;V!kGwNf zPwgX;VW?cT)xtfG-#1nPTw9tHDVv5BM`}`QeN<^v0YM#`am}t9?#~fw(_Rm1>KO;FrvbwF@9y2mKzS zF+Dd=mDZNqb_=;uezL!(3c_-A6n{B!OU3T{e0kxdzXr{a(JowZ^TqAz43vd!F6Niy zGm8XIE-6VC>xX9n&!QWo|LORYbe9d!32EKjIl|ga?Y$)x^OWIr?f6U|X%u)Kkq4Dgedhp@m_7KAfYur z_rm4l?(K%0A;ol+0qiY%+IYqf3vQKL{z_*N4qkFk5X`=5PeQM}!n+Re&M-J@zu64^}l?F55jTeN|B%nn$ZoLxNc7LT%Zzpz$?OpXTOqz~O z_KV?yAY0Ni7Q>4+{#a|15l zNO(N`vXaVBT$+gV@RA;3TeuVU&2!z=+38`sNhN4fFtTVtd7nq z+={%Ax=+9ufBOEV`Bk$RxwPta{nqJPE{}NafbPM8z5bu&u-MvwDe|vrda1{U5O?G= zkn->|dOPLQc?62o`xYhAwJpb_4_U$z3#0NzM8TS{>^A_)%jq@@8`Mz)^++X~N zq~z?P3emURa9nXhy_eGvcUk&G7AI$GYYQgq(`yzT1_Wu+YAJ>G7BlNEfN$xornY5# zvrLfrDYv`EgjmTkgZ6=sNSQsQg)kyn<0CxtNj%4 zc-_?8qBqbKZ;TW?Ge>PVHbgGhbsDQG_X0mMmOy55_bFCzKdNE;A}DE7p~bTRwIRf4 znG%s|0j?5liB{4^G=w`tC|nc&iKP9<*Sg+wv6O239E41>4~@ah*cswM7BP_r4j^5~ zMrFE-L|9jd<}%79)453}JwLl8Q%-*eC{L0a(>7Xphy16Y^?LH1#>axIX|=vD$A0e$ zVWn%|p9+sVo9!DTh0NO=soF!E<}{yVZ8_iGBUkfz_$*VoUZkyDrg|V+1z5QBGjjL( z1d>0k7=6#VC%Wx9M%8AjhU{|Br{A>|kh{q5QjHi`qN_0hs)ihp$mn!EyG+93ihS_c zUmswW6^PzAAMg#!jmVPIH>6I~{^2>_13`*1>APi&zy4Js-iJC^MQgL=6Q?kK&FiCe z(GEv!h2&dY=4sCG8xq^CIXSWAw;@&&VNdog8Z1XyS5Ka_!9$KLn6zV>TYXaPqYDl` zk7W3~DY%8mdRMcOAFBr)51NcW)yjHso5*It-8L<-mp-7mv&PLJJ+H@)Zk{2obG@l& zuXc(yd5{tbaE4{vwW_q{x1l1rFCT<75<6ACGo3g7)+(!bEy!I3TkJJ-)c$H)-qqz) zyqwcYJakPD!`9G3yAJy-Mt5~-_efyDSlOHw$E66h5`inu!l@)2|8 zTPAG!%{H^j;*mC+%?W;knKF+Tc+EY0e#K;haEt*h#R{|6RNG$GBPpL$!wfc|ykm)6 zhQf+`Udhv?y>!^2b1Riq%J*0_1^C;L_E07HN^N3kPxQU@YS)Wr?0ov5FED<(H!x8= zn9bgO(c}=c0PGGJ}<&vm}4_iBIE+!UE2#Kvv54j0J|@Bdm~~GMKL=8gF)VCyQjLJ zVBj)#oTA(k-m^I|p!%WKI*965_+G}Qe!+|tY1!lZLFUY?G(|I9^Z=KPk4BmNsSKfhtk?HGD=n2DCZX;bI-rKFuV1)CUvn7sz2z#G%N#4rn!Cs} z?wxc|0)iT{-)sN43`D*uNlu>R6*;E=Tzr`!=kzugs;#_QoR{LjPbyMFh?T?rNqKPS z=bhV5Y4C$Rzx?Z;$yP-b*;CM)FB4A>j93e$uceR6($I%l4mZeqCi^KE6qYo3QF|8k zNNeGV_hC-$mQYA&zAcFFDpCVhUfSsTAx`@pv|95^CvTyrEpeuTe^W z;TkVH*%Qrzn4rBrzUjXUlEJgokyV;yV%)=Z!}%clT)b|~+EU@t*#Bze8qy|i5beX= zoj&OY-*Bl4cQItn8z5$8R^GnyyqJg`y^yYr>9%r5w8+a`;mAwi25|j{j+DZ8|Ma%D z*JuG#WsU8O}?kiQRf^s7xboVNg(6AB-0!fsI)W3 z__0LY;;xVc$13urK=tJ$o5WRTHKdQg+o-M;wnKz|^E9uw$tc(%=MI`1)P-)aS1>6f zh|Z)!Q%;LzTM=VeucF>7e<3$B_H&Y~M^sDThuFN#Dc+vS3lf~>>)sW%dZ7>W?KbPW zv#=qZTvn|zQq4ArODyvrwV>#YHDRWhNh6%R0-l(VqV-i;q;V!CA%E81An75+Yrp`T zeEVju&p12286tj~cmMJHthd2!nusS8Xp-gK8y^O(o$DV<`#QO4C@Nf53{86$okt$Y zkSrs7Z~0o}QD8*Joo+i$o zX(Dk92oogD8ho^Do=`_;Y6j(zHLmiV6Qa|}*R z&s5Db!Ki{~ACn@PKP19MW5h(N&g$E@*@*8Sv(&>I4VG7hw0mC*5WfmtToSclyry2S zNBE)AzAT~1%^!Ii*834MzA~4he|8}IqxHVlLC4Crv3Z5=AUy06T>}FZAkGW+!|gsj zPE1_NR)jIO3b|`_zn*W2P)Q^Wo@=_GxTU-#ktu6*NB|~Q7#VoS(Z9`O@)&{ z*xuV7l7Zm)T~o%i{hWNi2JmPaT?(t2Z2iCudDEl?=up>kRxeS}Fer<;Q3Vx0>8kQn zvRHoJs3sI6-DgdAyA={73 zNl=EXS$tw7G*g8obRk zifUtkD@lWb@M$m)!Zy$U`S}uf(CEGv_J)#+IhL{}dV{n!db4s?BHrXATcJHAL~@@b zEsly<&hE7E?4;@Y=+rgZ^kP438d0p)mY7{jF|(gB@^Lr@$j|`)o zolT`2>2)VqHJ|q+^?>}ZrVfd6^xL0*QZ48<(Rg9dg*JzX#U*ttL7*x$U-@*2DHb|$ zGj-?W(=7YW02D{t@=$KB@8T=QwpS!1oX_0iMUGmH`6-d#prmR|GGa(P^yT2Hu(-J%QsSaI=U9@dhpjsD5}G&N zEMMoPNBvM`(!YSrmX9qzd3idoAJ*<*)%w16g}du?-EjYh`$?dVFv^z>nq{KIqG#;Q z22P!<7o1r=sMsw}>0N${177d72k0&B@`ofkVkcC+tjeX`Xf26ajJYw8%< zfUwv1bDO%fM1dc9MR}JMRoemi0I#sITAt_~4@)KW3L-UwNlaOOyf9%5CHdH^b~OMVQ=(Kh_DomO&75 zxV#Cnmir`#?5N3|K|y^lXEG}3pcmFiFWk(u*XC4U?rl+nQx9+7nqLkg-|I$ep5m5U4UDjNRzg%78CG;YjoI zq}Ovt`Hf}fMb!(Y=)`Ddv0Opi)ZZ=K?BNqU7sy}3docu;Dy>2J*qomlFU*Cg( zG`v`{%FK_Tid!=DOJ|P6jqv9nzlH=FiRC0V>Yr&=5JJaOX>5lU5v*#UV>?=-*&)bU^Q5Ypgs`!wWI%a=Cm}0woW))1q zeH68R9)Q%9lxu^IJtR7(ZiL_A68f~)D(I#}TqLrAAA*ySW!ei$VQ;$AbZWRN4kGr%#hHJSDbcEV(tOQd4(~ytmtBRUqd7z& zt&M|u=3mf$7B5ec@T^iWnjfJ_4T&x0c1p8CAg=ikPwb(GT|?WniWvzjkx zu7P`{OkeosKcSl#?GiL{xg4q7}!kPOFLQohWT@Kq z|AZpv)L}w2auK>XB}YNJ8i~+DfjF+#C;<^YN$-E^l4zM?{%VS;R>N?wrh+R5R}?Pm z+saEC+sNEpVPQqUOgoG{$Ba`QLS=V;pIJm5XgN5o2D3tbo{ZCx=$KMRugGf$ss2WX z4~t*QB&$_LiWf;Vjuhb2RD}OS3qq8DhbJjLN-myzerm1V3`WfPNdHiS zq_8*byBovT(6YHTEb|wZ(<~(LNzo#TwAPzET{I!FWkRApuRIhO}w{P zAMA7ys4_wyIr6Tdd=tt6LmAae*bH%&;=SYZPWH*mco9p8DF1AS0_HWJ7wqVPZW>vR zV*At6MYmZr6H%o1E~uiEnKNh%Glo=lZqn$k-*Cf3pqNQjvVhPYN_0tSFYRXDi`5c%?ehHs^*f@Bz4n@SC7U5wG;d@g1$ zH#z4OvP&FwpU(^6cVB=rYkgyCYwsn|delyF_qu2QDp0)7=)=`p8EDrH=l1u_(dkTy zytF}sJduMooo~AxzA|2}CXOCMzO`hJoe?8xwF|+yobuhl!(4Rjg8g~j8=kS>+d@`S zmaxZ=)Zq^zxRqA6n4N1uU{DptZUVBimuWoLT_U1!zt5(7=^od+UlS+E*`yFv>R5qe zFB|TgPqy8Uekjch zLDZVdkz;&LS~+CV6HiF(esd7=Y2~@Z7V3-;BUSiHOYA@?)Qmmw%`E1sKZvdQd??>K zk!-uWTnJEusl?okP=;XXR>z{u(nLz(Rx~DIgJ*_K?$F zK6ak@)p8YmcXz24lkuZ3umk2*K+ezopSLKyGKl^LmK1^f{RSH{@fGWESvR_%#l z{e!HZ-l5PF^*)e>6b%7a9^B8@Nj^q95KD{BjXJ&S;X@R{QS7v|{}CKKGlG5_ydKng zPRd=;_`u7Fr@})mziy|4Cdd!dpQ5=^+bQJ#A$XIb4o`O)!=OBVZbcRRV_`l+Pnn|p z^YT|e6W@+DBB}O|8##cCTXPruQ;Mc>&7RF0=xj&-(OqY;;*0145vt%%MTsTzl$F;Y9Ex9 z7((GQkSX_>jkFNIY=nnAkbFha1QV)Dkw2kyWS(WPFb4R+6XSMXs$G^qE4M(DXh|y} z5!bMcU~n%ocA&ybjSVdj)>4$I8hTpoMpr%+`5Q#RgQKAyt)7<%>8NjLq@iC^3eVNH zJ(k@^Mz;@wU-{l}2ASCz@|SM15~<^HkKl+CaGB1Vc4!38uP9W@XP5?jZyzWf||5CZNRdG4Yd{byZSl}QcI%ytE^y7%A zq}O%$gO=vWAWW%>f_%?fVB1#>D6WQXo6*`17#x%=ft=7T&-pl$pZUwsA}MuZrO79B z^n09qPSkrF%v&F)#3GJfX>)HY*x!;rlGYrYi~8ZkSCwBJ%Zv7t9B#RbajIq+(2Zph z>ab#m?6bV*u+q0WWqU|9e$}lPa6IrMaxgcwZn`Te*AvfG_Go`h>fwhbTjYzB8XwQQrc_3=!$NY^9U&1OoV;ND%b? zPL`{MWeaO65)T4Y3g3h*DZnyRL$0uC8^{u|j=2T=iIk&j4d0=Kk6M%|>HKxnPS6zJ z9q@&rQ^>%dLG?WGKW~(>JvCoLgau3p z3KGaf|8SVx$gL7N0ajOS8mbc3ldEhcgw1o`koo`@)mlS3etSdBjVC_RX;6n6OX=}P z&`N^kL;E5^`cH-UnR#LUCUj=!p}d5nm0RY#Mx?W)r4UD>%sP3fGFboj`Q6>-I7v=} zp*_TMb=UGKi{v=Unx?OE5+g6?#yEo!0{gOPpF2TO*TIKd4#yr47}VY?!l`AyzlW(Q-c0+xJyXi7yIXbL@yM)CWo=Rm-h0g*? z5sEeM@&t)t=Eh$Wn2)UT>}2iGr4o^0h31NnP+(!0_`I#j-nSXa+^RG_9o=#?KVLeQ zsu!YZm`Iy&j5C54oDIeqyIw?9B4As3Q$+q5>Z3^l^vmRUj)MYSKYS0bfd2>FaN)(o zeWi`=#IUOz;4(IG6mNV^KGsFXOfk$F+PGXMfv;8|G*8gJ4hIptp4lR><+%2s$|gp^(0 z$~@ffuxgbL3O{^a&Ot2u?%S7)xvz&47;J8?ZZDrC$iB`gXW2%b+2LL8SeGh~H}AAp z=d<$kfXW)o-}j>scGBz`dD8~|JVHtwP1&V!z)d?ikX&2&W?z6E3#7YOYPqJc%HA5K z{ANJ0+LpD$UBU_6Tf^GfAa$}3nf==F{4vEoy+X2-{3kkTz!@7Kil;5X@}1TZ_F}Pr zOZfPp{N8m5k7%pqZF!!=NSSd$6aI_+9*{QQeHkrvop}~C48gZR%H3*|6(l0&WfjSp z?nj%iu}}Q{xg$tGy<-r0m8J0w2ZBBHX^EM-F-$2FfiNT$V$k91ucXKR1o#0D4Z8k8 zhG&P3@(B?Oq$AiK6ugIC&yH!^^wSs5&}|_ZPWaD;PNJA0c(X`5n-OD?cI3f!8m82v z-a+Pvsu?XSO=KA)?>(jYtzZEp85bsE*rh zHO4?hToA{mv;X}I#+9rX(L07VZ}y0{5IkS++3@?$hVs!DOHV6UW9-+kC*nI=Mvljf z&)nV;A}yyeu_qEC4;hvraa$w9YZ0q0ho=N2ZUi$RuHjv5EC@orLR4@QD=*QRo8BZY zWEr3|uD4PbUDjp);j$T`J^ekzcg2q5?P@qZ@S6*|`wzRdZ`x;qfkQ7338T4vO8vb( znPfwOub2=!S8-RU zTlBSWsisZavw&|BnmvUA*svpx7o6BPh2Ctl zbF&sh!rBnDKCU42c5y?nH{z$qz1?=V@9j|t;=+3-8vO4yj@XtTwaH=+FM>h{9i#0- z3%RIm^?*-MxzQi7&}6LvMKdGDh18tBDSn2!0QK@F=yfuLvBNe$Gc;JVeP4cY0sbqs zPU>r(^>-q*jBabu@v2%+`c79|(;TPt$IeFD)i-41GX|{s#o2{Hdu0GdG}FtLg6son z;?%J5;m2aiz_?Ar8%l(Xr;)YA#GI2+l+0o;^=kGTYro$l$x`ng>VfH2vUqng1L>d^R$tN3T38 zsEB9Y5?vEP4Ph`~S|I%HTlv<0Z|KpsE3Hi7s*0vnWA?I6(t)s}AB4X_l^9z(Qxfe6Qd#9N7fBult-!%&ip6wd=D{w*1er|df%Y}q$ByJn$x>zcGCU1i z+fM|e&5rGAeDS1bDrl#H#SkJdx@BqGFbKYDuWo|Jm`g2$HU?&J%LzU#&1RBo8+%@- zRXEwC=7iOMqYr(>cw+L(KoORmNd+bzTFdO`yO7Se_EI!L&QeA7R#Uu+6d5N6Z_Ebu zpO$l76j;d2U=$ECb|J*;)S{qhD&EF@VIjt>ykdf|G6fYNw}>$2oLT==HnuiRONUE~ z-kB&(KSU^X1zOZ}igg>9zHMPoJBh(Ulx65yQ%KS99UE*LL78$Wbm{J|S;PgvZSz27P>H&itDQB%E6ibq zVL`ZK&hpJ<*@-AJnT%tJv?)`cmg1J!X*jad9G#`POedmuia>(K=A~OC-A}l(sR%Hz zP}|oqhq7hNO)pQf(bgyd#Fh>XmtZ;z{5+84wiz-ZeEDo-ReuxRMNQ!~ zFvB1%Q&i366rxWa(m0Q91RaWmt$9x#&`kO^N*xW=FYzKeIAiL|g@Nd6`SNOqDtj#U zYVXv;Nu@MfA7FI*Ct~^cTlDqCDsG9Pxy-u;%`b1}9kHNvAI zf+$Bkchtuf=9CxFq{U=*UT=B99PsfZ%wi2>nQhE+wZckJ zmzn_L(?Z$2wK$%!o*i@QCQTg7*2@!X^bvu%h(rc1W0Z_FIVyInzqcVI(F_OLY4^rO zULX<9hhCecpDwA`+qCXm19w=QvtxW2-44R}o52F^SatiMUe5V%a=Lk)WJoBSi9aaL z$$X-^mvu@YG_GpC<5ZSRGVW!t8E5(VgZBH|2{AK>1MTVY?YrZyG}i)G69XxdP!>*# zO$0IN@5g|KXb?WgylD7hdY6TF&~W%jR}o|IJT#|)x#Xjomk;Dre`!{Xbid91d3Rws z+HscA)8c6xjULx%RC5IK{?Lp5pxKhN2-DVN!`BlNTwOwZAA_EgU?fxtvGIYLikd3g zSu7C~0f}8IKEyqWA0<&=D+wMb_v}k3DWJ`xp>5WjEK*vp?mmxzDu_)giUZ>bicLjW z$@nA#v~^(k&Nb}o{(gp$EaQ2boHKnrB6Krb^aN74!zSm+e4)U1XPM^H?~@)_xGu@K z2N|9vix#&uyiF7C4HTNOt3GaOZd+)}PaZAoO5L~@sq~}Aei^n~do#DD5QA|J;bkyA z-f0-xk9z@6pCp`G>2tMSB^)!O=U!AJvlYdTvK(E+k|`^}*ZvZS6sXltscS++a3b!# z_^d=)0!SrV3ewr^jSh1k72aT?nsrZye|=~`jr>hBnBi=6I4K;~zYR0J!Bni;8k!27 zy=b|+5V&okQodp)=yFV0Sf!O(z$aMLib@}IfoCUtnEkjcB8d63z4yA6Q#15sC$nOx@%St+NxMFS8y8 zjkFfg&)m-5Ao*bB+9EA#ndw$#3ZAb|g8C3{eC?%dqcD$rjDcf=M2BU21Gt5uN^x*y zY{MN+1g^$NE^gkCtBwae8`#7~z$NvRu5f%{I+I_6OOfIU>a;DIXQu{ErgcbQjP|I3 zeMgF!`kYO_Z}a0mY^@HtXyjVdPyUEt?Ey^RICx|dd&)ET3Q(3+U5%5Zo= zrXFea`34_(Sg4w8WMEfc@yV*Aa-HY(>R ziM3aC&1x2DvQ7`YT%<*YTNc@D9JPK-tsi>}cbD*}#4QOscr1&9k%Cw!3Sh(^`>p_n z!(&ot_Vb^sM~O?*^Z@eg5)$4TKRB;K?s-W~+~%E#GyUFL_dqa4Pj55k=8P)}y=Q`= zEc`Ia`N=|i0D+fX5GzlJMpJh1hU`4fXtfIVtrxe^C-s;D18v@KNUujUn50SUFg}Or z%A97jfDrKa$$R5ZnkEO#<>Ptia#}?~HT;!o#rOgb)FJ4;(Ms+ZTpnqy(L9Yd4X)6H zLt9!^$8RKkFaav`g~G&k=SOvEK;D*)9w0lWNAYHKTLIv*eJon^awJ|iL(O|Zwy&Ta z7~8rWoWylK4ydkcMDNv!dr7Q+xZZ^?UQ%5N?K=ttp(1DKa?V1>Q3+a~34I}fE5u}P z8vU3S(7!VgDjG++)pt8&@=bEz=trKHe<>C>r%hfEZLx&=;@NP4lX31boAQf?9wt60 zdV{)xpb;rUo;;V}89Ag|Fb7U7IR^?^nxEoZm9fMPR*!|t1%bkgFG1Eu^Q;^!5!P<1 z8O7o=gLpD&?DxWlwWb0sxb37~3w}fQeVnKk(Z#V8L(K-1Gj{F~B7P{yf*B?SgL|L@ zJeQKBWvkm^Q5B31Y5}Qj7I5P;E$?%--Vre5mQ$lx;8O_0IH>es<+c~De?9KiB)ZhrJ?u35w zYcHFC-5l5I#heQfb#*C8tV+vlNCI}3uH&}9gWD-*|6u98u!Ac;3_O&N@_a=EO_lOl zQ;)B{6n=%T8%2BJV;oo8km7ptppdO56%lHe>US1R%Z2eX5iEfPfBdHlrs3Hy1WfPg zY4q75QAPJ*qOUYmT!Oi$_Gim9in1%HFLPd&`q?9?N7o!tS=3Yt?iiKRmR>9|S-)IK zz2hO9bJTw|o`r&;QIIC!ZfzZGI*@^1uD#RN`Y6v+-uIlzKqA9s!2a?|J;^WMOMTC% z44E?4mP3aU(dRI#KMRC|884MUpbQ7&A+%!DK9^T*U2Oe>tW8VT$;7+yj3vl8tHv`{ zJjcLQ9d>oCV`g7yBRO1eC^V~!{9yHa_Qg$+YN#mlgJwdQkzvT5W@=LOmr$}Q^+u^G z|7bprCbKni$YUf?CmAosyR)^bcz8I7T3)h)1?PFyM{7@{RQ>Xdk^F506005DEWUt* z6>{VDT@r>|PnYD?z(K1j75)#Ia0(AvQm{+(=O{HZ^!|DZf^DCp-kaJ-zZ##cXAGWN zn3Kw5j@c$@fPU4=86}y+RrOAE#bQp?-?;6wmR1zWDzs1%ZOwjMsy`!Nd6tfs2ztjE zr*29J|CLX%0a`vnaF|};+P5Q_)P`B^Z5bxg7GdpC2Zk*FsRG>bq!{#`MHrjuAl#Nz zdw-_D&rPwI)Kt!uzI-UCUmUe{`@U4Fen4BUdqremnnLXu_v!(6v|=Q^Q;;zar7DJm zj|~0Ow;pU1TPH=6ogd=T#WPHs$;t@HNIW4E>a%?H@O|OS;>IvZaT#3S^eJRjPFc@~ zl0!BscH-LVpGSSG;o22C`dEuYvvDZm7m+S@Z^U4O-jim|c+0wfDU|j0ML2#VSIWM% z{RUoi1_PwB70KXKT;EAVr~q+WY5b5`R@H%hdemo-w#vG0y6yObjSG+FL5_UU<>R-aU=R@eQ%)u3m%89 z4eh~ApGy8WA$D6(7ybMwqkyMvr^Wu&u8(#-4Rm9^Ah7AXcr>PmM2nHF2-a8Vry!-p z$6lCs6&W_pw+X-z)pb8XRpmJ6ZWxEIx<@N!8%3g`{Ri;xuGLFhl{$UKmz|1O{^~4c z)?Bd)8uvq7uA_+clPyw(ir1!1Zz*?&)=wOaiI)-s4p-MH6#3vPCytR@ul+EsaY}b* zKo65fmd2C84f~@jG1R3`1Z9{AoFjFIPi`s%io5xlCj#D%Tp@z+2K%zlShW^1cpHv# z;VlMFx25X&xADy4_hR`BY>iWPIF|lfP#`kOitJ)j_QZ&vns*(fYBwU|V z$tyfZkn0Q)B~_MJ4t^xiQG)2wb5Jcua6(PnNGeH*J&3Mg0?fkSs=S>HkPhCUj5|Vx z&MbW;S_6~OK#IdI%8C-CyCyo3T~hKQ(XFpEe^nTD(vGK zs+Fe7Uq2%g%wR+}5X6cK-x2h@Y;~2C)4lJ88$>@nVFV&nq9~rmxMVomQ4_v6 z4yfQ4mzc>U%^)1;W=W(8k-whtoP350wSj9-Y6+q|#h0eTd7TjQ(d>F-1ZH-da{xm! z=J;H>(qwHvwRW*X+;cZKx^0H_MHD@j=sL^eT(EU`q3b&QfJyT;gPR~b?9%zitf991 zH!PVXLb(-fdIIOSel>0NQ}@pXCT&&c_s3=+wio)g1x@91mhaoSxtB=v%%l@LXO371 z{;jYf^Eg)XFTi&?7on$`sc)v-PVHh4bSpC6H0un`!Gz2-;AU>UjwGvn^!P@i>N?N~ zGj#pah*Xkb5M)_jMf7=b`NVv6@y;{$j#7ZXx?LX2Y^_)r9CT> zMj++05SATWNXSdmtq*V)^Jt3y%tl9W+kxrFh{npmDD^^*MBD-x2bQiBR|7xUH;(jV zJo6RbJx!3RSAw^YR_Ue1{rx*K{3ox@P(J9H_b(0bD_sOz0&stuA4a zwSvqE%@xB@u@+JQf?cG(BjsA1>y3!M0>wZMqulvrJ9D$^&Z0rgfYDEpv`k47T$r}; zltZ^-a$IzOEGQ9*le+J5Q(FD<*)ofYK9;1y*k!ObYB)-rqx?W z-=s_q(UM>Zd=v4Y)c1L3pWv#lOQ>YmG%tt3)}c>ocXc#=h`ypEJg+I+H(I&whS0sm zQX#B7UEFQVbZY6%7}+l8+gLYvRIYL&-{F9_>j|cik)gAX{Ov^5VfzA9j?m9DDC*@J zYb+HfA12f*+l+9{NMHMG2-Da*w__u%37+~61EvVX@6|vDTm$ZAx|pIzyK}@N7Ts~7 z_jT9eMC9}?{thIb0+bLtuk>En80@}==Ide}ym{@i&i=}D9A+zb@g=>& zL(PIBad@ITLND|LkdqPZRgs5yq$Jg{cc6DYx}GSMo>j1r34h?YH2YoJ$MwaUudQb; zrgpk+7TU_}b0XIR223(1eF>kVRpPaEohP9%cktMI%mD6{A#c3?Mj2fT-s5SwI!&Gj zTtHfxOEN+=M@SDb_nYvI^&k#(v)MTqYP0%F}JZ2N8;vdLHlN700ZE$$ttfcMC|5)?Z` z=Mrut2Lt{R(BH!_&j;OqMowr##k3&h&?u^sH+&2xh0KLqOzY^n>(afawrKbl$BRA5EBE4o>w*OOV8|UU)}3yu&OB z81$8^SZ_R?R)jTjVd6p$PV~>$$4mXx`F{fM9uVO-+UxmrH=5qsPk4R6qq3V$OMmDs z1hCS6$99o|pE=f4;8S)bp2#{?yQ>k|s*}OM$MUZISN{Qa30c`QufsU3)C9B(U`mMD1muG3-=aWs?{-a!Nl-n^n ziH6*^x(QvtF{C=Svt(pMlEJ8dUm%%cmk#$qgq4-KdOQCK+$vSv&PY9x@xEY(8ZBVh z9yg=KAE!_xA;wiqfE)S+SgQ?NTd%$2r8X0@VGpH@WdU0n!#mE+FrL7Zye%B!=;N`C zXxIOxER=C7en5JSI7LN2^3GEHy<{r-QPJw}NU2K)aNA)1XEY(1XB1MEZA5`!{A8;+ z|GGVMC4F>ds=|LJl51T*%I}@9ncK)*2H{o_>$49O*xxeMCf z=xemt(w51*9W%{^+9fM4xh?$!zznbjWJr36mdy#wvh-jC7MPAKNRQVTwpf><5am@gEr zPpz{hBIx37Na(M{AzyF)Wm+J|<+NMSc|;kd3ZlyK1*Zl~B@;&O_;_~U2hp8Xuq1o( z0|Um}x$<~?K`{alX1x^XRo6zDs`4ynZSA^M-@W)}Y$|qBMA!mWGid{Q<1pR+7}Ze8 z%}qXdZ`r^cASNjZSJyKx{`^SzwFru&F^F6-V3k`c63kYd$ENz=mb*95$plX zbSH}PMflwcmc!s*k-)~~q3;e&;OwnOL6Z55z-Ix{9F-du?$N#I<~_(rV|6cDHoCqB zv`#9r)QgJ$;l5>h!czdE3`1sccuE&VK;?7ua=v7R_XtzS~CBdRAg+$&zx+u3}y>`pL{*NQ-D^bD23D#W_Mt zIrRaIB|DcksTfz_43U4S*gU^qfzY111{m#kC;hDO10P@JBI}G%yqsuPR%~2F*szhVH0+EOGpN@ za@T^X*~@15Tt%j?LoR33&R94;_$13F=(_;H0SpGV=_9zfDp7d%jmM}BVbY)c0ChEi zb&7%AwBMV*=U0iTVrw6!TI~k25#I|0F?;Tdkv?h~*rP$C6hqol<3YJu`cmgK+vtD9 zng5;b4#}FvOL_pEeTsVagZHZ}YyA}nwR>>tyTRh+~{!PC?l5yAc6#70r^n2NAe1fVA#nIl6R^W!e2$HWo@M|W# zfaP>O&+xIvBHqAhVK-~xZ%0u`JBG3&SmO_v0o4q{vTkfc)H6$QeA1V;yj-h=3Rao+ zPy`hInUdU^w@dAXq9Y-hJSwXel}!MOf`|=Yv2;5WcHg!o-&y$2ZNa`tK8-nR-JYtD zN96Fc&b~tSnCDuJ&(^|wq{NYr-=PmArtq-f=eWKx2DH$Fbl945BUWd+rQI)4)ZVV7 zl1AYNr|HJbna#{EkvLnUpn9pH!Ai2h-NFfJP`D4^^Zes7%Psyx#Gd~`d^n+fPaZCy zjn~CYP6G~@oDGPiniXTf_PF`#?#J9DC)rvir z^+}ZX_@`A>*Bv7*+xxo{b-Gwh63l)E&B>CU9Bamw1l1DF?euNhH8yaar<$h;AW0VR zQ!hZjguY1@O&hRn#dF-DtmeFja5IJg@NXKUrFb%E-A?KDE1~lApJe{+y z=+Yi;)7|{#hf)e@YD9&14KUVpHG7hm^4;heQ!tGjX)kS<=!6>$z+c3dfEVsVN)wOX zhYktkh1nU+ea^ypv$u^*tkZ?WBkjppicMh3E*xzsHQAo0lO4n%xSyUXf6@^Ug3X)! zsz*uL?FQu!b}Us~FG`)5LX6~HY<;(}2#S^`GxI65z_^iRTZ8>FW2= zSRJ>|_X~X;C06)Bwm(N%PXTS0QJPA3=$9%VQ#x~%7lMov26kxR9cPqv)0_qLNaQRw0PYDcy@cJO#wle1zv6ik6i5xxco5Mz0QtQDfIxr0+=GRi0VW_*moUA`d=5ugmVM&SoD3wu zY-!bO)4s}Uy;Y5_jN(Ivnr6_P%K^!C8f`>rQbe?!8Y!R7f48C9d8pK~UVzWsQCnyD z;qu+14Kwvu=rF|yZNWQm7aK`;8<2D9IX*+zj<83oZKmJ&8bCxP^$bBifXL;)&%Zy% z?2Z8fRs_!95T1h6T|IpA_VO-ufM|?#z^o!hF1qlFt31_-6F6+z%mGt-Vs*>Ff}mr% z+n~GxO&n#Hj$6@Ek^rkkF>Z17%VQrb6o$GAD@*Aq-;&+65PP>80`UW(!*iis(YtHF zol|PdfG-@ob|kkj>gneEj(pF17-(Gkg3?*Nf7t{e_RqL(e}zA@W-n<=O59Y4h%>#O zYee#_vqF>g+=I61sXp+snNF!sR*c>@wk)HQpk^f8U3@1g{_3aZ#~TvjR{0q+cc!SpE>6_;JX7OplLRCMjOrh@zbm>drm|-g~DO zVY11iqdM;-6MH5*q+f4H57BcwCyL-klAjJxGyj<#2S?J@*;h7c3UPithc zt0Sq9=h+D;bHxos8(Yb9{oXV2Qf+*HpO>XLFtrV3_VJZlzxU;ps}H!|+8@v3+#-jk zQV>C|R!U}uYRA!66h<`-ZuTO1uN&b~LM|ZW91Bl9xh#`(nP*YAc@LczZu~6D>n-5R z&{j^WyIfjsz87>g2(0}}QW4jox+uBe`?Em35wyj`72!3aF!(#<6x|)VwY!ZFaR(6z z=y8~EWFBkK(L+^_|9niIknLjx(+e9z*9yIzNBXqv`hQ&gnxR@A;DG#>NhxAZxaVR# z_Y&ApXFj9}4B#mevy(Wcy)rVM2HGAQ5LIEoTKiOQa<=L=XHSl-Ng&dUf`&#fkXbQ` zFjga>At}9%#O5hw>mv|vo?b=TfyBlO4c);-1C4%`(&Dvn;( zC-xq?X#zOK+cpYb5yVt-<~z3! z7QX`*6bT^*IZQQfcRfWtUd${7r`I@_148A3Ev;pisiVm~d=uR3 z5gD6aL4_-tkj@bIN;5AXod_$ZBbW7}Q=p-|nq)1G0k-QBu6Ht>) zqB-EPa#yiUAE_)m7#$Nz3KvkSC~nsi>2;iJWe|6I<7q$DonHB?Syq&& z*J_Hk-t!-qUG>NzM{sDtM^L!Gx5#>Kboe|PYotTA=ESMwd&LgAoOT*R_#O2h{fbwB zHLxG^3tdV`R^^fEi`Li65B zh_F=aRId;sz0ByFc4S2^rgnvt-! z++1vqA>$eza#sloV6dyK=L0?lGS>i_j7X^x-}QBGB?mFGxYbe*0t6jA=5|M0!9!B( ze3`eeKW-1Lef+Rq7lrxJ*O1hKOOk|dY~P2Ur?ab%@gaB#x*xp@2av%=s>_|2w*+ph z?lj_W3P!b2{HG~LG%O@}VCcALY@)^`4VL9Oy*4xs3Q0}hX(D9|dFc0vZEaeq&q%It z*L72=MHCII)*H#e*ssHBvMS(nciz4Zq~dp}%r#eTQNcud zRO1D6p`;=ES`p%+1Lop;SS;JZfkEefZ%c4oG%V)G2}K(4hI3gfK&Xt$W{Kz2-c{0{)z>9D!BgIJ9FViw6^- zDS=gg5~OzOepCY&*h@fOl)}cquGJ}D{eWbeTvdZvsyn{Gal#c@fgV}#LWQ-qSNLXf zqjSNf7r>;^0%4dg1R9}7L>08cy4cWK2}VjX@0s2l+byzuV?1790Xl{z%Wugq7N`Q$ zZf&$-%BI<9i%HS*-}>PO_;yS5_&uUi>#M} zTZ->+{Zk$Dbe6gMMiY_?zqHitxU&)dBMnTZ07rPg+fgDm&%FWg#c#|>Pj{YnnJT`E(fi+TXjHa+6z~9@b!xm$G zh6KT(jQv~0B5_2D*3$;N%JXZi9A4GRp}>nmigb!q6<)P^X8Jaq;+}1!ge{`KSiKvq zK1!!4QRTk-ma(WE~XQ92up8`8WAIb z#dBtzg5VAIHpH}ziSLi%(7Dm($eo+Tx$4-p^kFY~styy>(Oe!#pOb~Znbr_(q2q>? zGoms|L88Lxh*U^HDDkZ&qyWxpQzhgUP^nkpR(syRp}Bv**3gi- z2T}qhM5J%hUkscTW&wyxP>m`FbTHDr$*PeUYHG3|F&&j?tkPO=60YY@vrgWHhNOAH z&zr2FW5bm^uO+4Qc`z5Mf?4R!d|Zu`1AIN~bE=|VmZp9xc398K|20A|t_ZD+?VE}b z56`oke4h=v+JX3<%|8e|wKNM`CU_Wb$RF-4LyMf~Mk*N&T*Kt+@9-Jqpctj`?*`Fqq|*eLD&6p8D|)|bgC-@ZM@A8jsg zYC3AK+oM7GH8c7V(ZYF4mM^A6=CPcGxB{Hr3f;mPYW(a4u7U0+{t@zV)R=7}qa*0cFR;uR#75uN%CJJMxSF}jB2UL?J05^PyFaKyQlwv|D@t0zlG!;oT~$qR zXs6}+!$XqG-*u^(N@LnLD zEU5C@dd64Tmo07O5{!chx-OGO8E@487juV}79m9lHKgQlZRL~+?86pghkcsn!=RRW zs~5FB_#rf$An+oaL9p;->o2yxWNu<2O%-2z#3Ho+l1P6O3e65M?Io;{{RlN&^Ili`Goup5;y2nRfYfuzS7I*Ba-6Z${7OrTY%tLQ$P z7{6S1R6i;vg#*>RbSG7tjs45fSGRY=}2NDVVT11 ztv$k0Vb~SVZ3@(4b|{lU=vJzB(errwl{oRkvyT?Gb#44JW>a^eXg|CcDqSBBZ9bb!Z`}I z^JtJE=_b|=@vUKZ!7(?5bH4)cCyaejjjJJtgN}BJJZX(OORfH(F~)>)70%eo2wL@vxF+H{ zA3oi^Nw_aFSAl{OYUn7>dkv5&v&AZfioM3%b^nHMM|qmzVC zlYQ4mrj`kXa|q312M`$#8Yhhs*e`3v{VO13h)jphkHeR5hmH$H8nNsUPKSo5tn+(pH}(_V&oI+55bDT|Qs;SzcFrZ|p*-bz%clMq!k0 zVyVD%4!i27N?;i+lYeOA2kf-yAFO-x!gzR-keQ@tV*-CfRU-fSqv$DOlb270daTk! znm7XmWGw$`$a|LMNBAtA0BK8G2J@b#)N3HOA8L0)$PGg_Sy68D250XLzD?w}CVP zlwUc3iBV?1R)6>LUU#$q1In3QOom*8P4F|2=bwBS)`IEQYeL z09GPV^@wgVD=W+(fx#h~T1nx)ybz{gxzLY-n)fXr9>>zv7mZ@q8oN8+L~7kT#tKRS;8#w)9Z*=DY}p||5hU3$cu4}WLWzi{dXFXzvNuDd{irr!qOp6Ax9G69JCha-Y< z2l1m<+N`y<@dUY9KLV$(;q-R(1o01^wbhCRheq46sg8f#d$H;p6Lst{M)qE1_X*Gz zMDA^~a1jRL4hauO7&~xIF$i`^h)Ve^4S*QY&h4H*A*D*d>D#7U-$PQ-`+;QrihF5= zH?@Qp=h9qbTGn)?{CV8Fkg0agEU~ik^uX6hQ`&C#;b=qQTS3kdrFVgF#~r*q>jd&< z+(h$de)M+Rsi9;|t^ox$u+~AqO-mee@qJ01o==uQGiAq5h8=S(=ot|90uH=9|7E~G zuVJBIN5os{4j+DhuT|Tu9!?D4IJ_KDPVpK!OqrY;Ym+-C;eWI6O zGTSf!WjGNQd3cF+V-LXsNtus#3_mq1{d=EYX^53q{V_{vYH{>_VtOv-)W6pA#Q5kD~N z55V3=z8Jx+JvT6*IDeAYa+)-U6Es>>)JfbN6{rmw(kGuQ^-{(Wqq1>!D_GuA)Mk}ZC+puaVQziVLc}VbQjgo2ZsP=0G@Iqp$b{QfGv61TUeRk&} zW(?ndKyT~}P|DGX_-7-v85LjRV52z#N06YKFTQRl+&A2(QO|wutm|>_TILArPz-v~ zGMFb1V&j+9E$cdxTTtKpkGp_;o2)PmmSuXg1_bn#vp*PJ#;M9KW)HAi5YN}W!xM&4 zXzR3{hGQ6pOKBy%De-pry9-tt$jqVc2)lb=O%3=( zi&21a!w%GR6J2(`{jpX=WpVKfBZZkKMxDd%Q8H2RU9#9VcSU zd9n#yh0BnC)oQmV?igM5as9IM1k>zvg<3m1LYRrE_8zXpBC8KNfaQE^?5uH09gB%d znIeAfwCLIY=gRWPuufZS)`ur?PQ2P3xWfkc3MPSzx8PECjHNpZ;zJZG13F>j9idf( z1>FE#9It&aYy(qfn`CY%6mb=MX}S%1ayIV)OH_TaM){x`f|Z$w0}nbl5Zz|1 zfHBslPm^DD=)6*U!a3T-U^ygB*mP|WEp^vVhUnPr4_s)%nu)b<5PE+TQsST zTe>>do~QHq%ndGqY`#BE4!ph&5WZ^`EBADvu9!_&B^0gH^_*yyF%6=@C{W^aK)Omw zg>nN5Wo~41baG{3Z3<;>WN%_>3NbP>ATS_rVrmLJJPI#NWo~D5XfYr$H!?E{FHB`_ zXLM*XAUQWTGYT(EWo~D5Xfq%%3NK7$ZfA68ATcmFH#Q(3ARr(LFGgu>bY*fNFGg%( zbY(?DSP81p%Z7|dx^p_ZgMi=Dl0(OK5{>wnh83cqr%cOzOXFC-~2td)* z9>Bo`;NTVH;1gtL2XL~p3;f5>(OD264Rixr0#sN5ijEMF3kr>tqm!pI*xCmAoaR42 z0rVCO01g2GKIT8%0TK=%XRrkj0#E@$Z9ops87+YJ04+xgFbL}TUm@s)ZJ%B)ZiC^G;EvHWcaw0CiQ_6NEF!S+D&XM;Z~2Lfaz zGyuTo2LEc$#ljiv1a)C`0o(s>k?nVw=PAoTETtSB96%7L3(D{Mq`}T0i|4U>vi-SP zJBXt@#QQH`1%_B!{cgh2)rn090)FcXQjq@3$MpF8mNc5-wASUooZ@&#Lgp1)AMU4U*N0MywP%!#eX9d4i11N z*a8YL2U&w5DE~x%7K5z*#Lvrj273VBus?H;1Hk_K^Y<^~XL?yWLhL>NG5=$~Y?6lh zipttde|G%0PEyj*1K`cV#SLKLz=I_J3RzAXbh5fj^6V zp3;8`cKd7p^ncw31K_`7sX9KB76hRGhvP=nc1nf`~%{~y7BNBO^T{C^9Q zb+xzuLrwpO{{N!}I)Lpx|1x;ytSj`H|0<5pR{;56Q$5h1H>(1&1iL!?uT}vHe7*w- zh_(ISV+6a%f;~W%>R_ma&7WlXQ?B#-$n3!okh-G_`1h*l zjQm3ddOn>0PALPiaJ2k=VVpd?0HCuo&=ZCInMj;GJOFQw=To!&m3n1{R=*4wf-060kDDpfgJ1rHpt(Q=Q%Ir zd20XCKL>OCC);yw$A780pS_))A3uma$O`(8l;bbypUnLy)^n}S|ANnzxcmz~PwpS% z=WVe;-T#&Oc?Mn}=RXDiwLc42=jT+=KQ8Qfx&Og`JeMGl2gm|tb;;2}D8#lQr0b?m zg4ms9|D(t}&Awhb1B>^nbGPdqI#LQlZFbPM^R-0E_`vIpT^af-@ip=X?=S65NMRjG z8lAs&lO=UWk3; zJ|ySSI9#zl8M?HuaZt;vgnC~w#}cCxZ4_9#KvQ6zvq(UR2xTFC$%u94fw6FPJ&%<) z{Y0*qz=Y!aHHNFi+wc=-?Cql0W|cOlOCKRMp&qM2Av}L`3eKvkk><4}~9m z?dC4bYKh<{HG95B9!*q%{r}Og$RJM`DNJ4?EqZv-zV+yR z4E~nUsKw^QCQfsk0J@nBX?u6TXY1?+_rT*#ZHn;?k1>UXb49PYaJS=KMthvION%VW zk=}zT7fT016POg5=H?)gqq>fiJZV%W;wZev98%Y7fp%g9q8O@_?9BXju4Z-AQB&iF z{V%8tS+z%u6S}YJA%?%SYbPg z;jxeOp@kQE)dLq(Jr}3OMJ(*XtQFQ;k{D>J_Q}|WxoYvsr}G7|Jj5mfO@la(f~86w zj0is8Wl@4cp1cPm0Bd0Z6-zSA+l0Bl-gd#_i+0jT;qw-?vo(ys%`q8Cv%C_ZN0R zT;z2BHkp@t7mEANnrFlhE+}>E^aaXoFbT1MT#!vbwBPi%iv~cpVqE*gS+4G%s<(#GeHqU zZ=RA83(kJM%5zY!WbmN7+l`~;0&W4?(B-dvzI-h9Eyk$C>w%jz9JWj=#dnGoSXk7~QY&n&9 z-!N;k*IHqQ7@Palm_9Y|)jXWG9^Du4tDQN99^32O z;d)V27}JG0i~SN~v?AZW@rhr&o~198xs>Z4=@m!lM8kyGW%+p>fxfLp4i~9iiw zD&|HvO5`!*eoU_ndozTL*ja^>NvabuDDr^dc^X5&bA{`aeAcF!r}MMz2R7{}dsjyp zc6<XtE(O z1Hm)af0f9`TQjIIhIgnbcOp$PEsoDt;U^JNAbwcDSUP7K(L*B;C*r=82JI>}4Mvuo__>zpWb8h8CSVLSd#q*|er3cgW!wxps~?ljFcd4f)! zp6dAk#HD?mX53|FSrVTq#*N_U5IF3rNFe#XQv^Ceu&Nf?%o_^YY6R?flKo+7f1kyl z4m7Z$+TGK3bvrMQon7D68HlSuB3oTQ>Y34q5n*WXlU};ZaaofFJPLK8T9zQTZP-sZ zB2N*ub3ULY>Fiuwx%TmXPM2DWq9GbK(7vM6yo??tvYmU8=eWc{s!{>*Rep?PdU2K{ zsP@>*Hfi=#Jos=vZ$5S(_XX}acUx>zr6LM?h$LFna8BjYRW?}@7oARB*t_nCe~|fTYJNN zXEGZoaok5SEYvaBle=-ve7J3^Tf?2tS2#2PWT zA#4NHk4%bbBfGWO!@RWl)L*lH#S5c)Vx3SqVf>t~gM$zSU)t8OYVW0>zPJh_IHIk@ z4CCKl$n&Zn&XIEr7wDT@pftg+z75cPU5xD!=3_`$SWgzRcPZP=1Sx z#`7)W#WYJ?lC*LYkE!#j{QhzETkD|GS~fE0!_uJFN7hrd>NH7F9)K##lit)mkNgFR z2a7Mm=@T8(1%>wpmYeh;jDop0jxm;I;e~|~DtGGUA<>~Mkm7`}<60+aGf^4P zh-$Hu=S3zUVlqy#u{*%Gn1zu>wYMj93?EFnS4n$(l?)1MnVKz^L`^KVbfb7ju-Ih` zN1)7O4>;I_3{~K3IFLU;jl8jXK92{2`JNceFUj-BcrX%@=J5&AEl%Dq^9xp5{YkVV zA4H9#aJBx`qz$s#2Shcf5XHSID72&cRO2qz?=-m6^fZ+;_^<Qt zGa?$Pj^EguDdbR=tgD>HqEg&zfN4JKyLcQtZzFZW$7jc#0^q#(sQ*q83o}89&rn&K z5?GXSX?38$QAQ%RU<)0j8|N2fqmNd|l`F_wLqdEp(aak;3Qri8{z^EQsi2|U`5JJO z?UB1;8~8yayve_|Q=oU>Yfzzw0{;C-i!&xjPPJEG)kz{El^apV#n@cPIst|(hDBNM zF#0DOZq-`Nq!Tu9CG{nS;O-2E$L(nHkFhl@d<`sSqpQ^Lwbd$a+ejy*CwM-M?`U0yqCcY5@aj_xSyMqQr^DVPxnu5y1VZRT zELUUG92XqPf0mlQ`?iM}hm*;#=M8(vQ``l=rTmMqLeC0?P|1f~13`VF`NsLm2^gb1m2omtjdHulSv%%&{hl=1flOGuYy#dmP@f*Pqs> z%#kdd)5+U^tS9IZaiIH4P;Nu?3n$MxnqfM*-$4=rl}P*5q*(A&CCYb11n{kSM84^n zcuY;wBX|Th4Lz;p%J`Gj^{+ws@n8F@=3Oo+#7a+uBqydv^j2n;koQsq#uJRgZXpCv z8vDYu$l~-4_a&^#Xk&AZIcS1~k>3wEa{=+#N52eHkXe0B96dtljMU1e)x-7HC0=?_ zgSc+`^r`~=(@<$MTUv&m1xnzneU79Ro;=S4{zhUpw2mc2-HzSb(#zG-_Q4;4K{>A( zO=NwE$f?B8)QJyb+X7e+?@#?wi5v#~Y|oOj6JN@@k?4*9$Rm`_R#;yn8POROUXR3H z8U{t?VaJe0gfICVUVeGU7Xmt5OT3G)boKl{`e|F<~}RYS4Iz3{jWqynt~PZpBsP)s#!So@m;b40ChX z+H1t8xw;+f%xj#(F|HC(m+}p{-!SFe7+tV?xWd7v{W1cJdMpI0m*ZPbL?}^6y@~E- z*Rbkm>qxjpj{HSVxP6+H3!>2a?86zGBs(J%vlI`(4d4>IlCzBu`^n&Emy$WTszN6b zRl2SzDn-(@5MSMh7T~ ztBR*bf5A!rX;nM4w|N`Pxm8y@0A6w~;G0DVr6DQA_K2LF;x6Hf`o{mE^;<|leb`tb zkDcG5;A3}=w7U~!rI77;odo<{HS$L@Elr~q19yT16InRo$hDF5J5JTc0 znhtr)CR2)-KkcwBoS8Ta@rV%#Ost$?h-zf3F3TB$k%FtXe`Y6Gr-eF+c!$oLVvJ?5 zFUU`c(tl`j)$5)w@$$*io^0CHRZ!WjwPM^Z3gI2VMVhoYtXVS=PRrKhnQ~)suVLI* z!B~k4zr9H12+}Qlj|L7C+baxGl(c%6Pnh$CRP#M764-lBo~nu429^FDOg^#ouwNGn ze-F!2?DEOG?kODc8+zZbSp@eH2YA}qh}x(sY1tv_)%8JUr%nsu1!i8+-j8%y+2I~& z5vRCJnTaSL@P)q%Lzfc;R5MrmC%5etr~2=S*YLd3x({$ZWVXp!72&v2t+e5oIbFY*}zX}9|vR3d1I;dk>Vdyz7Y;3azd zXC{B}IZ0LJ7b%xwl_*NKvtM0fUS(qg*n_%MJe2jKo;#c+}W}=_nv@Ho7CE34t+q;x zy({!*!LrfR*dwCj2>JR&?1e*zE=oCbiT0bW3&f(;C1A)Y-LP})TF+|hM-irc)?=t? z^Bgl>!21DphP8{C(p+c8dCVPdy?0K_)cL3+I^Lu#(Jf`OL6Q-~7l6FzP@=bM`5A>M zKr^*TpSQaamgxuuTRR`Qj)~yr2Ro>DPS`Gd=2SHAT3O7Zi9gk%l?(A6sNDGs=M7r> z{RsGJ0C25%Q*Zx+-mz=-32`CNnkd6w2IH%HQfpiPQV3H(w7=7(2p z7zie|oxax=;2=0vPbzh;ZCSlE*7g~ib!E@+`lP24sdXq)7oP-o0U?IjBnqCh%eu{a z9Ey1fT8LpjiWyqGA(tpxlFeDMYhp7uy4pQza8ua)c`y#!iV9btfwhHokpm-Lzi@K# z%kIV{wa`YiCDZI(LLM-tT)mFo&z45LCbVsAToePPSx(PBMLBR*3^pStY_Iw3_Wd>d zWetahF$*+zu>uxG>S&a5^psm@!=Ec|AFi51cfKNw_x0nX z%)Nf$^$wmSIxmfhGHEY>xD98mEx1DWvwUPm;?){qa}0;vTHa52kI2sk7+uHO4O4TK z<1jAqEQ3y3(TJ7(QjHDyZv|0;-~AQ2TY%|sm$)p zC|3Z1$Rl;=~S)%*2B*7*Pn@5D2Ub7-rm=VXR3^&%c5}QeM9%1H^>XyQ_yCo)b zvCQ)n7=s0Fi~9~MsEQN`^^C$b^=w)Vuww(TA}W&tzWStZ)-}0y?j$&wRD&(QP=0oM zAF&TGxeWnsbde7^)|t|wD9>CJD-XTW&K>T&C=*g> zFcWvD=c0HS?iNB$?2P2%_csRQZC%M%$W^2)X7`xUDG|vD=Tiw3C8aDrWGfs`<=A!vH#JHF%I{+)F62MZeiB!A3@ zwT7cxL(YU_f44q3IvlMtvQ2TbM=t$0XX#5005XMU`2I>UV^*@ps5Bo?QYhI(#fq)HcIQq`*HMu+QWM!; z`F4)JlU>q7si#gKT-xFIDMbOBhs}W^h~^}d|E;6jjK$z4UJaL;3R~bsr2W#4r3Qv8m%P&22m1dZM*4> zHgX4a_WAb7;1}>I#-g&3Z?TXhMto1O*m||=wnWilO(|GfJ{Yv+TrF~#4XU)or>5T) zukTlXqJ_ms4Q0PJDOs}cP3`(sRX~Ye?-vs5#$@%?G}~wHn91`TJ6VNl#w_ z$=(wu`6s%eeimQbD_Xw*lOioaEH^z7CqHmE~2q> zL6=n&GFq>atd-goq2)YL0~_`SJTgD&AcgV?r| zDeY*Jl8D>!&ZBg2|MKw1WxeFaEfl#Q`}kO-FI_t=(nuL%YvA$D<7`i+OI*J_xjtEI!C&ViI3>dE)p?NYvmevip5F6YS1A25_62rdo0- zv-ts7DLNMCu&!T$MisZ%#kGt+PgHhwBr0Eg#YJu2jH7D}fXT`yK3W;yAR=t{Pn0Wp zs*-k?@cfx#puR!I`Sh;&>sT4R?=Zez4z+uE=g1MS2$gI86tUR_oHLX80PyM* zxn}1KZgYWlwE>5rv(sh4YgBkp5tgG-un-@2 z0CQ@4G2<+QJDj>|TW1#Tf$&BQwc6#IWRO3}QA;SH`Lq`^sd1_6$i4TrB#S?Ocm!uX zyI5)~F!+2B?U4kH$Ir>BDQN)L#T1|5Q>X6a)ICackT(VcnHz>($n61sGAZgd0gr4A zfpIU5;zt@|`$7Ck3DQMshgRZ?9oxh(wn=kx=L-F(B zm+@VPY`$AlZp5S2Ptq8BZ#R#UTI%}}Ol?`)qcX(u7)&Zphl=x%ih^SUt9)~U@C)Yg z9b35>&59!nb=vV#VNFbJK0j2-nEpl{ed{sX_}JTe#S=*-199#wu80NE?jNDchuJoF z>~f9|h)RLp87($P(X%$Cv^)=6>8Sa$nt?)O-btH*h4d2fdw>7&I1iJg@pw09VmMPc+fWVI5>7VbtrXbTlYJXQnv#%hJJg@)xr6|4 z6d{$WOrs4ZPaa+ILKbmrB@#@0yXVznzp%I@TcejB9);8uJ09b?i{ z`Lsv1I_n9zfKGxMmAaEsz|fvuzZ@a?XwvcuUOcwvD4`Kn2`(<8n2_xe+_vweb<&h^ zn#3eLsru#Yw)X^|z?3M>M}&Zl4`~gql7H#5nYW8?mC%teO}mUAiF(hL!FDL2m2c3A!qksJu|F3FDjLiQt!aaeh$@0`61{OjEt1~Q>bzsTdrA2;nb{&!%e4s@ zFtliV7()%lPM*|yJ0MDZSI2&xkL6^OE#C6^-@PVUlk?R3WD;0H6@63@?}E}9p}ozh zHRgmB1|;-!dnNiOx(<=E5oUoeCghGAKvKN1I%b(_XPU$*DG>W4a*j*rKL1-0lXU$s z1z^Iln~`#T=)&Cl(jW2)qkZ?rA1>ZH1Gu4pC?JfMj>#89{NuqyH9QP<$^pq*y zCELPH0s+Jjuf8LXZHhW*hMNdi>?PVQR+N;-i!GgGU|KQ52kPi!PO!;-t`%Y<{7%-8 z{q3B!p}p?PD1i9z*RuM-A>o)2{&^#_+Goa3ITsgZ)qF#|K-x7)9Lv(tD9h#y-1{_r z(y#iOeF^F<3=*SJlm|^AUkUUJq);y}i;<%{yg9Uxv?qb;tFLi6gz9Qt<@Yzs$cjBW zcEv#XbGXqBZxd!2D>~Pr${s4 zxK$n_O-ci2LrnQLT~Ih^U&^B3e%4dl_mMy#pWu9pAuC(YZfo zvAa^7eT(|!eaL~sSO~-IXS!JEMFy3jc(UG;X?hLL`9KSOUeSV-%k^>Tdg(Rul3>K5 zE`xi9Q<{0iT+0iR+I<(iZGA7Z^B{bLs`~?{>ynj3@@beVtSnqZ>*!dw`!f1C_Z%{b zq_`<&q$XS3qE^9;>YAx!UeXDQb!|b4{Vt5$$V&D7T#|;?V~2%94dd*8t>8e z*od`6fnywc;8dcqwJ8hx1rxOe9P(7&r8(OWw)VxGFSo+(@dNVM;|*Ee!{Ote%?!3Q zdQzF-qI3zxE9m#FeWRBsDT=d~4or`{t^4jNnt+|?UQy*k?$=?lzjw?E=0p}Xr@_p>>inXs+lbl1S7W@EhZhcZ5`dZnM z28PS$&!_zmT8qr!reYJHPY?scm)xuhsj`t)AXj(ZX`T#Gs>(Oj>)ej0p%EpFFol-m z!YhwgHYVk4i3UAg49NL_r&HZ8x6#yhyRQ`VOWh(s?Fc)Nd9QhzD^5(4MXdKLd0GI9 z5+mi}^v#CRup;;BUH}~du_3!+>E))|@`o*6maY#vk66hk7{fF8C^2Jpc!wDV1$AA_u?TuTk(cnTq=2L#l#vG>*_GO&=)_vL)3SALK*a z%U@K7%83BW@~Md&-P`Z9T6LjVJc|asI>6S+{BiZPhe6EH2qR5+d$#tEqK;7*c^e$Rp$Qcymp$+>0c+Bd&B zj$h0$u}GlBXkGgc;ReTXdzNe*IM_hhW2dd|IjtVrol_P!mTDi_Ot%lL9wxI{I31MU zu)&uWjNMa{Ai%aI;Ii#5+qP}nwr$(CtuEWPZQHi%c1*;HnTa?L_c8xL=FV@g^_uoU zp&V;I&UY%!?>RnU=jBWe6SvbSNU~`tzGepLrYk(&OK{-pHqfP^Y!VmR++?MFj?4da z*c`=mX41dDIh<~oI@acrzi1v~<&-T-{U^j0d8JQlP3{<>6oUmJ%u?Q+x>IL01P|TO z_iLR@c;qAofa})_-dDRnAKv?jR2+;fSO`Vg{-+kQvh_+6sSXk>I@Car%0UQCc3c{M zyKPu(vfmy8fpz3sk~yPr{2b2^N=+I#wb=cg+t4YPGk11m3N%&Rd@a`K?^H zlQMd?fiTAWOIEP7A_LX8tg%NuvIaceez)#=Q3c(XTa8@#VV}%`(N$mTJ=5lm^?UVB z=+F;~bfe9=FJ>sd0V58ABo?~4Kij^jvF(J@mg2Okw3qApWUi>S#=mVH#$d8x$d2#| zb{u?j+8_BmbWoeJ+i!jVS5mhN|INIz{5SK;LeKht%_|!VBg=nI|F3yvXJMlMKjig) zV_sW8m6NrwSfyK=l85AxfP^IfxlnOf`o1Z7A-6Q7K=IaKe4GW?g>4+Lm?nSk@>8Bu zp4;ErXP-+AtK8ELtKHR|)$UdL1xxcrDa}D@0Z00BEG~5LG6a52m8dAZzVY$F{_*jc z;jwaHS0|8flM%xu;P$pa1NnkqsCZXEjW(V&W9lv317!nwf21wMzG2`!Puihjx}kB% zy^|x9FFE`v5eR&veYh5|az}tK1HMsPsY7A(s zKHw`;@HwFNKA?X|5O;d^z-oT^)i4T)1?Hz0vukjgJeec-QVHUL_Fpls{gd+%usVOuU#KQ~=MbJFtu`%x92#moAYV6I!1$yk5Or>Zuc+M06zH|_ z>6Ag#tG6h^JGG23ozxIbsX=@Mgr#ZJOEo`6ef0R{!4@yT-|Q-2loP<`cjz_$f)&bbmo|Xx-rU|^X}lv7*dR{NZ{(j(?|{UO3C~2#*&q6!O)?VDN07I= z$2)+v_IGx`z<&bNS69G)x3|(<-T(I@@G(zWq#PCo|E+92Oy@&x@WwBP?@_O@ALz}E zhGi|tTmaz2kJ)x$eAMFkZt(fH>S>qa*AM7d<@mSs{?|qv?&j=mbNXxZ_t!y-zb{tT z50u*+?dB!lPi1Woh5wgL8Slx=R7GG#pZ&n-U%PF+2zX%tG~ukUoO5GY;Aht zCQkil&BYHkg9rm^!M{DwZ<`Xpl~#7<_nt>OHDz#cdjBJTY?pR!aPP}YLZcjY>SHz7 z;gJViy{%2%-N1ntA|fjeesA!ZK5_+rb{7*2fFqy2H4LQ>n1|0Fb_(=zHG=mP9H7K6 z;|CuQK>oyT=ocG6`5m0+ZRtl8C>tPugfAQmVCe%35(>y))vrje%75h-v>kwdj_=L@ z&A;w9@Sm`qw0on=RJBJ>3lsRI84BZhga7fV^ykmTr>Y9kNKdgZ_i-_wR4F+^hJVRX zn5P)Q`EI4Y;)SNIzQb!f8>dG7({DwKo;aS@ahKL=oH0v+W^v>F!n;x^#@xMP-E-gV zlaS9+zZlKJC%eF=T1Td_C>0_xUPE-h{yMX+MmGldPGs1LWE9J!4WLF8cQ#QZw$oVJ z>TJR8?JD-@H0)$@wYebilGagADj>2L-JY7kWbABid!>v~6+D{jzIckR6ufTq$}9;v zTle*%_ki+&QSH>*k$bO8vAFMgjcLO`n? zr}-3`b2HZF(b%gy6 zTJ}v5109Ll5tWOotf<3-sZ>q9s=~iXpqGbj--LKK)7S+`s#3|KF2V8K>~fDf{V%_G z$8R|C{#Mx+9Qir22Z<|c4XUfX%vb5R8}kX?A0q*Iv05Twe*i=mq<4!f2TK>I(DmGcN6? z(7u56{BB@DHrO}dA>8RrgFCk3K@=viReR%Knc7To&8IYJoEQ}$^J7dZiQD+ z*Lt})kO;_6JIHSm%z2}#J0%%0=@jynu~6OSl}N(}!{h8JFaNmHa#UQ@oHB=`au-qc z>`Bc{Y>^@1)AmG@nXxKEg#EbsPxlNGD^^4@n}3`3=0H3L#||dID-OY$y{3lmiV!a8 zG<>{ikG=(G2~6yE$m9->9z68%S-B^aytRi;#rM@f34ho7)rM@CAy*Pq_7dC)O6Y?lyvqiR)t2np zN8U_LZR%v@EK z0cK}a*2r#;f$m_gy56_IRqhzjkXH+Exm6FFjeoslMVPbcdY1#lSZP}*+^j4~KN)f` z$uH0dhdADo(DYDp6vBqls8khkRGr5;AP%)H74D~LDU*Fz?qm4;3$%;$ZWdf# z!EfqLo?z^LgD;E!H7aSqq~PIk>a1iya!9Vbwh12QUFMq3`n)y*znkTB$aJ7c zp*GwEH^o!|h)olT_{iohPy4=~yM-A@=rLS|7gx|0i47EoH;v_-U1zGzLD;)(vZd%% ziDb7{=IT(tT}%kqmiFXD7~pW|U+b{nWG~$XH<_q($lvnrgd<`AW5Qg-^PSi&L!|%> zL^yEQz_bO?em{dh8&&|w5SXU9GVX2PHs@UD!(ig<8y?oaYuhX_X(dM5OoRw$YLlg~ zkyrMoPJ5n?2`%bZ#}sw+{ zJ&uB}Pf#U`#Y!-NcWb71XjH)->d&emXpoI!5R674nWrjf>d-f2*FwhUy%4MTZFq-c zW54`et+SJI&dI-Zm34egK=&jfF_)N?hHJnk$@IgJM1DFPMb)%c$Q+~}9iE?#o#HZ` zF>FB9g#@1OgT$@8oqnYPS{7>N!hmzuQEPE*X88IZv)DC~FQ*EJUC$Bcox9GD}Ug2 zwIn%3gvg|yeOGmT68cy{~DT|TxaFw7~Hpr0))9l33=N>vGk=#T8WcH;Uh~&}X*8Yp+b4v)p zzuTySBF0~tQHcp3BSbcj^mpy22?9E`xRaeukjbdITTkB2hJSei6s6trxoWqcsVz-* z(pH%#nqGdr@DhQ_qcbrICK(tWeyOO^^RAmd8^V=V+_I#-B`~3;C2U=b)k20jF5|Sg zs|@Rzi6p9wKpZCKh5BsHRCDiTf|rmt*9&tISm$WR!Kz*i_Nzvtn8(Xr-fMu}vsjsg zXS@4BXI`#^h*om5t@0r<_2uxdb>8|3+0FFE{;aSGzFLM&Wy_^x@s%EzD z2-VlQQhPEWDi$f86%W4%&v+RwH!>#&RtMJBgD|-gpb&7Rp7~PFEUZu>`b66FU|nsn z1K9#L1*76SbYAbCD(W(sPX%`09vAQE&<=NlyeD~Re1Qt66Ec1uH`w9^R{`&)t@$ax z1=8OM%c8lh!OYVu&Zs4%YgO!1Dwdye==IYb+8*aPP+c+%tYYCXKPeUGRqq_hv0O9N z*N~#1lH=y`h-y($0S(2$2=qx`99{}j9xB=5His-5uEV#>5{!=WTYnM1Z1d6i5=T4K z!qy@|wi*%DYOw}$E{ei#UG*La(btQk*%dw*yGF^NhXvg^vxxrhok9p&=nb1>2+JOl zDbKdSUW0t)3hlkS=^boU>n?{`MDLb}>hQ!O@*WKpoYA=q?CytU)fyS#Lwgm-`7 zPGGp~W|)06g?>mS=$3k|of`({JTtUq2>ucvEPl^xxiOs7JL(vYXb+erOXP6rjC5ZM z0WmP%UvbIn(7u0Iqh2MQ)dwK8A9JzXZ~w?is~#xR#b3slZQX25#cq-^56X}4R&6w8ei$drpYU=uk08BD_zJtl~P2PH5mTu+z!g$~xcf^U@ z_=`ZKe4NOn4hb^%n3s8$2rd1)5qKXh}6nK-@ig5{z#8;tSW=Qle zcxIy~p77zXVWQJkZ&z(7EIa>*&^sf(Qc+eU0y#k4_XR_Qbal|ycDr~;#WeSk{h7c) zj)Ao|8}!PRDL{$&NCs@y{z;Z1w%vR!=|0w6_Ew3Vu_Mnk_na|`6C5@xJuPL6_tsCs zTFT;M24n7#yY+P!zI+nou3Vhh#*c?}8rtQB>dF*STBCcQbxaM9Nwyq& z5?*C{mX@yI2KnXJVjVJ~QFn$+>HqOnd5w=)yfoWufw6R}Ih11ddel~;MA8P9%kiw* zKam>UltmfxB4W4$9mj9XB!7e`6bpqHq+VUh80H#uBd~|H&*0m&ZII*+vO8s&oj$>$ zn{RFmSZUkJ&~htUZMYaSmr=;GWAg_MMKij?J#{L~K=8 zz!X|426>xua&fcsL+Hd^r~yE9VC52IR*?-;s6I931!@?YlxCJsL*_|~4|ib@l)rS> zZ?08Fv{yu6d`$-=>+wuJ4_^i`l?KvEzZ&&+2cjtPCP~4)79>{bq^~>) z@>H;8!GRdC2Le%1Mvpwc`>nI zuHOf%DdHB~-BHoCjQlO#mg-2Si&(z)#7h>6Hgk3fnU!M6buzH^nTjKI`)%M|>&pt3 zT|5y6S2Gn2+js{FxSL%Jr$&98igPSE2O9!y402r?OxpJpV*FUG-Zvh_UGnD^1g!ZV$+{aS#Vr zuu?#KBc&Z>WRDv^e4ZuTX)tM6kJ6HE$Vo;PRgGpI1Sen^Zj_0s&bRHixluA2Se2-h zN4H6muenp&!exHzP;BQ#MYshlvdf&M(dNF2o_^R<(BqZ+_~QX|%&h!TZdM(1B%-Fc z%QS&GFIC;a^&m8stmlfp{3w`=M5rVbon&t>9e@U#jzIn?;yate=Yw|Pq2T~IZ27=?Ke-V( zsl>KZ^G(af&h@B}R}$5#E6hzF`*kTxqed>DDc%_>$>Z4#~cGPb1 z6SqpG*c$~BAjW&`K9Ro4Y2~?w!qsh&LZxHbMO$K~>PgWbe8sjy;z=$dW992L;26Ja z>V#Je7c8*TE|zn!F1D;H6fz>P+W=LD9~E}|EKcVxSXLNVyhtVL(CunCWbx5-?m&h~ z58MnJV)*#o?*$6=V&qBZ_17t*viEn)DLE?NW2NL2-KOwY|+N<(FeQ9a?D2`Cs#H{(E#r^W2 zT4VWL;`9y45|rb-hafe|har#rqjfF1FmJ4f0FjkF;NL1JGtKEyG20oSe#~i{JLD^; z64cs+?Z_cO0IiE3V|uaieVVnxPG?C*PDy9GkNL)_y$tPgf6@bRKswl^nFKsCcNp2t z@-3)F z4|)^vI+JtE>=fwnrQZ6WBFh)7{mfJeN0IYk%k%KDBQfs@zH94*wmscEH7mYH$i^Gl zO$>tOwCwV99->8r_eVTDqvmJ4p~JRHx}m5xh=yE}HwXT9##to5Cs` zL0rZ*B!p%SxADZ^6Rm%co{%3Q`CGp2{lVaSeu}bz-uIpu89_S(65ij#88`{PVPq8LXxsO>+4lG6Sdl)?C&gy?|{(@`3e8$&x7p65Hl=9@{EDi7vXIZa8i_k#2U$v!OBZH<<7Y|EXbkGCt8Q%hE|% zr-H}ugCP^a?JKpA;v4UYpx@(RF2Q+#z>8*Vp1EXuQ7%vASQ;TTiKQ&VtNDJxDmMPl za9teNzqmi#Z85e7p|Zs)F!n-xoG~@B7bQKzqAbppF4y~3TVpK^i5ryMu@Z#dz0SJ6 z<8lTjrL(}_DoLwKlTse@slgK+bpB3a>WoX00?CZD1R;$f%x*IW&B@0a5MvoN$b)Bo zIA~qE2~p*iDW3NDIA7+9NvL=uDA;Xil*393KTzhTJ>%ctrvmb5lE)E{*f%0~?t{ma zG@-tEmEYI0^@);2G6C9+w)!rf+9rk(%vo?%;pqxychPLBz@uCkni0f`2wfd6`S+I0 zr-e0$Yv5JO)7?y7F1oDrXAd6g_L#q!(W9)wk~MkE%K~C?`Mkjn{jwlc^g2**C5U78 z>Qo>8vGo9c+(+($urqYnJom%BVFSsYW7kIHqmXZ(Mpz3je)*ln?HFKaM9; z5)(z%3XRDUYI+s8$r%lmr?%dvwY2X^XI8ynfJg8k0(kXM+bibE>ZI9HPs1T=eVhI; zq~BA?odmxU?_UGF{NaJZ+btWeebM&y_wKv7+h;{cr!%5oE>^Xw)t5O-H|f+MK@*N{ zeukI=kgFi;<9&7a%aYhbkyYJuDRYwS=-ONl-LghAOegr9DVz2qftRwae<66J%#W-N z+z0Y?>{$_aMTB0YvK(MhoRvhd8bCXRvrT@_CVw?BXgFJH(bzS&%jJ+eLhIHB1}9Ei zxYfXhDw7mCqiwLx(uHQ$x8O&bC2D}3+cOEWchkx7nn(QJ!+&^9t;FzUL_gR+{1kx^ zbl|;T@o%NR^O_%u;G7^*^oNN3QLfA%vN}WeD{$(0KyuDcM^xnpHRL^H*Kues^>HPp zcsy%+rAURS6e0+Q%`XRr=uMR6o)T3FJqE2#CuX+SF=JjYQ-0 zaZ7Z=3K+WMJ}!!>eyP48_!W%akMHXG^Wj~l)yt`#qUHV0Lta76SMq+=g@5eQ*yPzu|gqfT*=p(}&d((Pj-82^A(uuORMl>y^;L3|Fzw;fTBm>FzCM#VH zIEZT;A`Br#w>=ukGbr2pSpS{A&4{Ldd#5=H#D78bD!T>9$)63W2Wa z2my$=ve#_oIY7VLgG_qKk*tPDLv>-OdVdr8slsK!aC`Mc+vDrQq*36q-Qm#fZgXd}(=0&t z^qsA&b$O^HVjSonqVj5;z8gpH>0bKR#ZzH3FH`EcZ?3CIH0>$7G*G^Rc%AxlGUHF; zGONiqnFBGEGp89_(OGR^Fe%;2M1e8)$^DybgjFNorD%hrn}qBq2qGqhbK>4Ka_w5) zE$t98H=XzmjQ3u0`Mh!#oTQ_@u~q!q&LmqQ)EW3m3AGGT?h%ly(v_}Q&-Pvy#vngs zv>`N<+B)*3x=#m-;!s>B&+NeFmc}~K(dxno&rlxlZr&w_)FXPF)+I+f4*DTWm2gJ> zr!|gEDM!A5pAi12QP4Vl({7NW@WPNR$omMC$=p!Z5)496ZtJQ#Jcr>|!;iU|jRj7r z+sXQk>1kz6NA-z}^;M>(@dCA}oJ9to1Bzm@PkSs2wHA0-iak0JU|QO+rWfSsQr%se zMcwqzYDkofxmIZyE7Fw78m4!j%6=OXEf}WkM$eN>l$%2m=D(x05#vGCmpKv1iZv0x zTaUhUjW{~YER$la_;=0yTWPHm79blpqHQit@ zSreE5lc6wb(eW(}Z2safPyme5>zaqITS)Gs)0+m~=xiu|B{P zqJch~*y-f5R#9`-Y5{I9E}|h4h8y>uVGuc9!$4r4+F=z}{jc=-4ouA2JSB|!YLFjE z#5#)*^jQx)PXUfVgC0Hw1{xoUPC}W%zbyv1 zPvtG@-hFbMgtlDb(Lqmu!9k`6#2CgIdm*V~!yjpvRC|P*k$#P!Wis=yw5CIe_@wIj z5kTZh0xmnmJ`T8iHHJZNC z>oJ)OD*3Xam&sof0vSXxnz=(vZe6}AOO zgE!o28+p`>8Usu)7mrkTzY^%dza_xie;ZYso3{$r#)&g!Bq+hO>=fVyrQqBw%?($- z!7atUT&0~O`jKAqg%30a%m8E*SfC9tOnj}ni(|4s7x_P*O}X7oU+C-9XZXkat)XH* zKeCEaT{#?;*B`DWt?K{g@8YaFSlwCHU0?gaTiGc`tx}=0hQ(HzLxc#q6Umk1HoPYz zUwniH!Nvbga|VlAsK~2K`}wTn4}m4q?m-57=%JXBp%_ti1+sKEARDl=DnxUspa!S z$3gGD^M=XRRS4OD1ictp8YhAuT1dFBfghE}hyovjniL2u>K_Y`**B+K!$aw_ffIV~ zPk>neEm0Hb&p)%0Mvd%YT@)hp-}uqx563_tq<~IH1Pux()c+?nU=qkR@+p}CZh)4M z0WFCT>G=R!p%%z6K;4|g^mZTeh~j56@E{Tr5|BQw;glaj3-)H@LFC~hUBf)|cF$m* zfim%P_UWDPdIj&cUB!xgj0N)h`uGvcTk{~0j!9?fKwyH4wgX1!`7kH}PJq5tXyx%P zU_W)zA^fq-FW_E3fwS;+<^$wWVBBHd`*RE+dac0yf}vqRyLzz93rnDx?*a&ZFfM-> z5P*J`G4X{#9^Be`yZk@{iF~<)a&i)Oc;$uZvG>88L%jO^!7e)f-F2G~5F+j0O(32h zgmgcJfb;F?$`_maZ-)x_T}X)VpE`PaD;}Lh`+eqo34QHr^-u$SL)vW{Fb70H&#z&H z^1lIkACy9h^k-Ie;K9CeE6ITVg!g@MbPgcW*7Qo+-@gK85bX8*(9VOKs&mEe?!?~UIBkr2Y&_DKEe;a;rsa4tdjH%?A82(D*z+#m;k_q z3O{x9Q@^TTT0s2x{OD~=m}ekPK|}z*!o8seHGW5z<3)P{{8)D^_xSvGwX?fqomRH( z_=vjwzv;iYwBl-$f?_f%cW(WDmB}dy0{qc+WS0l%>&ab2d=Fk`Rq{Wkqb`lpw4W4~U0r{LQux}|Ye63aiS$Fo`QB>5LCIkNgMOvl zx>aU!SK~r=S@8TS^;e}HZ>g3MX2jFscVWN+ zg%QM`nxXGHy6E$%kU-y9tyF($^z_1A#rl8JK;JMSg@2IuIdvgmp26SL z&S!qem!1!POHW+%eu#d3P4w&V)0y;b!Op!eW5u>})XG>Sr2_^oiyV`-F45Y*2GTi{ zJAXMSe9?ZR!saK-kxQ!jSC8;kmfm7fPuFP~xM*PC?yECIZO{w&uox#qzPY}$ERB_sfXQvINBBK1MFJ*201AvDPCmerkWU5X{k#)h& z>BpV=FH35yNFzl$dg;X2EIEnmqt%3@QEWrUGo4+#3c9 zi}8htw(QTY>MDoJV9B~UO6?xnz&yuR=!-wFX_3ONl@pz3=x60vEJf6nl zGt%Ym3l^mLE)ke8mv!C7pQ5T=Zig-o zc+l)l_LnF1jr-8Y2-0{)5mc#L4;D$##OIHNBfz@S@JBvrg_Gr$?sX&;L{iNgeVpCe zHuA>Q-$7flq%P z1gTd6qrbh;=vjhN9KhvnFemqp=CkLe!DFs{=xA^fGX!Eg`Dq1y={u14yp}#-x>(;K zYXp3Kx9^b&hlWfO9n|&nU|Cm{%m-kU)!v*|5Lc;w4S9Dp>n(LpRvea=r_E8mjZ^nvM z+rN7h5MD)z5EX)8Fg$g%ckV0es6UTHKw)M4!Z_E?qn35t8zNT>Q zQfLtVnsK0Cs(j{Uk@cG)T!$lWJam| z2~m-K4OP0Yfu5vP0}c|prf4b}t|;t}Ng}sS>OeGjdGpZ5e3jC>oQkpa0XGPy4^%l> zOF`oMaj^$*$5&n7s>#zIJWt0IPz9xl^O-DYP!YrWZ9xC8Y}A)fvj+WWz93rv<}zdL z2vom*BA7!eQ-j)QmHtojgxkc(oeRhne=Zp*xUef^(kiToP-j84Pd_E9hqC&)PeCMI%tf6L$AVz?V4*Y6s3}wAS8DDua@Sz`+kG?Ch#&EqfM zSVF=Pt_l=2KBrkHd6i{Mm8smtQw4By{WV2Ka0W1^J4d+NBTA(E{ucT7Yq8N!2Jf#Y~#x zT|?SzTqvg|-6FyV{5>37DZIM;$KnXc5!IJ39lb3~R9~^Y)+O=8-@guDvyPpPdY~(tpw~O1bcHin_)G@SDvyUNB z2(|Xg`)wkIX4*p8)*??pa3JiKooF`iUHldE2x^8|jSwDB$GglE%AbekmuMVz?E?EbeBZAyy z_gjxyyaCu8XuaPLaB=b&(bPH$x*-@kGERV+DXI?Aj|~(K%;AKW?f+T+0o?5RBYiUV z9llpJJwe@h@5&go$T$+h&$7mY2lN}O%e zfnrC-J|@NRUE`9!eaK@N?OiHb)$4+~g?rilZhHER^QcX7@W2)(E3sTV?O%eq?|G#y z+#yILCVy+zV7|Qj;;@?@VzWFx5C?av5v2!ojef=vGc|7G8x71ij_TYqau}|c<ZOm$51lnh zpoiv%QP_=!|B7AkjShUA3G`+ClD3bLTTlXTI}Ui0PCV^6<0AIZHK?HicP(-ZC8KJd z&y7mDi1%jid@VXf-?o3GumRMQ(#YQhtwTv&MGFnVQh94l346T!`4pd7MeHRxR|^g- zvWjvbUe~zWI%&62`I{=Bxr}FHwk(!?Nf(RW5pRj^8M-G?CkI;S_*Ro?qkOCV9I{6p zrTn4=UdUQ>3qrs!(j7r;^klD6{LmfdSRf(-L5r(vqGf*@3UcHCxml~Y!w$AQ^ z;MszLOeU)nvZP+|yQa(h7D*Q-puZ^){ZH5}65e|7g;`MBn~~qF5w=4ZeM`s>&@4&}ideQBy+7{L`%2fEeZXW@3{S50J{}83AJ$Fy{-JVuu>r z8|JQyr=_h#(Ffs~s|x>k)3-a^ze~m@velLH(6!qEzAcY!Y+u@KcF&ge!z`(FhdPU! zKxPZO@?VExo)}ie5(h|AD4gaxx**~Y8lOve=jt@<<#tej%Uqr?a@u9^L+?ATd{1kc!MO{%;bi*jNH z_Sb6j5{%vxr;@gLei#BJ_34dN^r6;;elx}T(%9pgu3NF`+eh20PsO?Y@sv`)oQiv| zSFR59wTSV1Xp~A+R44$Kf?2XiXu3tbr&o8#T1W5%MHbDfH@lws;Ty(jiV4~HK(rWf zfE6+fFke#6@oGXjGDVB5$s8qIQb9i;R{2oX9vM1~a@|hGd6b#RjQ$CzXkwn5{m-OZ zvIe$9q`b3DLrJ;7YplUX=poH~ zo(cuyj}?`0Z4QA^{cs1Q;w_=fV5^LnnVioEqg6f+W?n9e=^qe%e8c<8Q!H8{x52zC z@SJ~69zo^9`g`iBcOc+7^9P{lMu-o$JMQltKuLaZM$7KKS^*-T(I}&Yc6pFRs+rZs zZp*Cfugzzlapg=-FqkJUAw(1Cp)2UHBM=-ez1OJPJ?$9eL^*rAjSYN~*#9*`t%r9V z8E&wrbWr;&J~0&M-!s@N`~WngIwj_HrzLw!`DCjYot&fZOv0h9cl1OmqG#%8PQEb+ zm#*fBdLYzN4kj)k7EYYDZMZu z_75JftAQ41K4ginPep%X4Dn4$?h9>$qF73l~eaYd*-HKddDE_5L;iwnlt~B`CS!;)GIB5H=D=~ocGyh#>2ua zSa)&p+UOI;Muwo*Ll^a-!KDz|2iYtr zF|@cr5Lru)FZ=<@bXIm+DfIC$OTSQP_(mP>JX`TI#&){l#%B?tp_cza_t|r_cD`C; znYYgak5X|3B_qw8z&zw}U{U{T-D`buR`P@gXcd4@U4)$WM3k5{JaisUs!Qy|tvi(U zdwL>geo2C7Aisye1d@-?l%e2iUK93oJ%)nxs1lc%Mrf-fcmV{>NfV-5KW0y?9254Q zpVSz@?D&XZK;(SxZ$c>jSRy(QR;soS5(kA*ai@m&BD7`sO?jqenm?W@f1~9$Pf_fz zMrMmz`__XfTyiAiz^qN?`O(b& zAY$wIB7?AwNQvgymrYs6JSF+Og8i8G7iAK@$@a5fc4d6Mm=ZL;%l*_-^*4Jv+PK-+ z#)Fx&-Yl+Ml4@g{Yz(_`sn)e~5Dg1e+prbLGa9qQT!7b8-~G`|=OT!=ftl{VMxDpn z{QZfNv=@PyKZX#|`W&RI7FXoZTS`Cqn3!p$BB1X_3N5BmQnC?;JA&q{`vPymk0bJS zA{#z5+vY_Xcof4oUs{MCMMcNZO;#zK55jw*&KZN45&lK}NY3D9Lnu6`{GkTB#g`n+|RNI~LmBWAL@H4`yA-xtE z+yeGO#7DGsc#->HV&$jFMl1?M7E!&c< z6Lw;Zjg%L5iucjTy1MCcb#GWWgpTn!o7{E_=ZhMqMP~EMlCF_e7dplR*{TB1S;XW% z8RyfrBVJ=9Gp2}7iB<*5=GNRpOb(u_Nc~Zx5OWRHU|Mv39Dsug%0H3kyrOcr}+{rmCQ^-e)L8SMz1acL)+FGXFHNYtR^)i_$9%J{>HK&>1)dQXn<=G45NV&Lh_ zeR&%AH%a|={g{4Kiln$kmZJ>Zx{bsrZYwX@)I7?AE1)>kLX0OX(zHBBO;nTo-vGbi^YF4_wJ%E#N1kRS23KN*|55C#V?4ExkgS1B{k$vYnf2$U5b!6Ys=#q_6QznuV3A}r&79gB7gPM z+M^=S~>K++-ZqE|#2E*bv((Vdx zmZYYWUpvMsu`}uKeAr9*7bc61s#hvHtW zH^MBB>?tK!a+Vh8Qm=2(dhn{C8Bnz896ur?WwDBiIGk^y-t!>#LswOeJaIit0sfD( z!st6ixT2DhdD z8w69=i?VcDtRm%&(#=7!?`Mu$*JuZv80TWEb!$2J*V9Hqo&K9qk>xY(|zXxrf8@VaKWYBW4c zny$Wz1Y1{F{2HWOES>(7Tsn6{1eU+nmcH<5vWNw*NX+y_-Jap z=BQqfH1|Zh)ZQ_hsCi69e~cfh2(PE&5)S7eG zZMiL4{YmotJq%ATw&zY!TTTYjS=!f*)`4QZe~Re|CCV)Z8B>@HPYsXI&8-#yt9tRD z$%63c&AngTK|5V_gB}riC7Pk~7PjWS&RTZ#40cMS@UMC^cDOPvO(SWW;Ujj0yLJ<5 zCzi`O@09!wb|Q1F<#)sXek8I{rTp~VTgn&%O3}eJsd7_`lHNmA`lFXM*`z+53#gEb zny7`+-E(ihSZ$+O36DdBNIlF4D*nu{<@=1CLw&7))QqT{q~$EAu+_}P_IE=%#~M@X zHnaU58Pab`-7czEG@4NVn)VJ;`ZQhtFH)@Gih(%@Lzku$iiPUZuWUS%%$Yx zFWxvP<<#WGyZdaui2H+W=N}~d4W+dOnefME9*Id2=9$~c?Bg*6fmp`&JF?-fz6Znu zNVEwSTvFaf=W3np*yC&W%_{WP+cVXBot~tj2b4O~eP3&JZ{2jpfM{>geTey}mbdfutMIN0gk z+8Q`p)<<`Jsd+9@t6fMh26{iH*qRh`mm^5M=!CJHqmg)5?{e?W37rC3JbuRKw>`xGsp~oh*yY8ndxvV>xx)EUK4fEo|GC@MK$Z>CpDSP z>DJxr3|hw<74Fv2h_xSUY;N-dx7%k~m|V+{?^Y<2rls#k1w_pdGl?^1%5RJW_s^7- zS0PkcrfZUMlGArHjlu-WysVqb4xE__7V=!1P9#=AG#%wr$(!vTfV8-DTUhZQHhO+f}b8U&I^S!9UD#4l?rWb=C%qB6yaaA+AHB z{8G}dInm#3y?M6ySgH2WVub~0Db(zLjLp64^jS@~y$-m}NpDYTP*L*?PEEhlt~s=6 zhwq9m-E6s^^}xH3xyf2-P<4P%F7b=33Q`{TWE)W85X%Verb z+A2mFIbOxK`a-~ORGr@BZHtOb3axMg z(c~R7^ImBQcW6-Na*0hvYT3Aw0LROqOA>)6B}zL>H9jBnGpsQEO9UvzxHhVZG_yAA z!~VxyKwLhoI`v)dlKU-KOH)HMkX&bwuN5t%f+GhPKFdwy9&BsKN(PZBz{kff)w<+9 z`{CJS!VDM^Vscy2U;%vTok-KE|9e<$6YYWD0sHf0!lQDxh`lNP9|&ihinj0}ZI#;i z@%?j@ewkn`KSVr2e!kZ6$`D<<(41t7H~H(oN1uiU-U5?2pUubAlQiEzCcT6_VKlt! zt)wMFyfA6-d7dDnP- z#Dd=+e&BT}%x3#-6AEOiWP*j5mNKK}gGK$>U@Q;!FhoREIgBYOO|8jND|8z?w+^0M ztMU}GlXEjUtVUE+Om$09mui!n3Z+1M@=lQ8kU+`KR+F}i?ddkQ(^HFeat5R0i~a~S zQUfASesTs^L961@by+9=cqk7m$YF0L;wk?a^il{Z5V4|^mG1=X^s|K8+el$lJ3ytd zEerF?=c9i3mIe7%CYC5 zSm+D4e`QcgTm|i%F+_TD)->F;JtZT@{=H{!*(SOolcznIqyAEMO>$P=yZ6Iak>QD2 z>*_JLE|+Aq#hV4`Qe`sG5+f9bb;kE6$`Uq{Ao>SI_wSH5f-w zuS+!@dZbnbb#Dwpeu_m3OkiOTtR%(Tgb9=wlqwFR`}#nJOS&~6(K zD;Mzo`7Tk^MVd5NqF<&~%J8==do^+Wm-R9R&;aC^!3~OH@gF%*pz7|t$r9X7>gubC z!f&#%V?xs4kZ_RlkoTf-2h_+>(S8N(gQN4r_TJVTRjNM{5Z7Cg_NOs(#cMd7RP3pT zUk;zPxxgJ>)5OGl+2Zg8h|UK3*wjQv5CspP*(Q>W_LxBKsg9B~NBA1=e!Bysd@go`)DsvbK=JAgvPyq>A>{ z+AP(;s7i&5YfYfQp>HH?BTgo|aa7!O68uM7RcrcF@u`Q>F5}2Uo8-K-6Kjhu z6%E9tIOH$95Mburf6*kI|3#B9b8`HTA7LV3V`5Mj-)6V0s zmCtTQvuRHEYx8AK?LSY*TAIt#`_VOG3j!(#&NTTLd;$;(>+>_H000EZ6g&_lVqHDv zpLvF{U0)zJVhAKqk-p*|;QX+^{`0GRqzoTeW#Rt7mUs+*AlUIqmgXUSwoh-x{1;=O5t5QnPQSC^#ySP#2JY9DsKgydjEfnjh6DENUsA;Ou{GavzJbL-10OF)ZXs1$EVmrwD%t%@NbC#GjvgfO5!&e*qCP(BHJ`yPfa%kLaQU=-IiO^`+n@S%Qr|5EC%ybwznoIr&IS z-hYXJP*a1zi6(ku%|$|itncJ=!w=w3y#x|-@Avs_!O64t3e~e(^J;^{7|6fDLr^K^ zPqRYr@AZj6U?G443LyD205F8>@4m?i`DLlUcL?^5i}H2cv(vx33cC-+pR;-zJpVf|@An}PKt4hR1OiG*$goIB zpr2owLg0`e%tL-fm3=sfKM%DQwXx^7;k>`{{*SSIZT@~M3xe9n=s@;AnWz7T^>N$J zse8Za*S$(VekA{NAb!X1esV-%?HNUtjB0;so1n_Quzb^^$DNxJUhjhUsTAV&2>HXee{U~9)nfWFnPG<99+R&U{#SSkHN305!O&7@4)a0h-;r~V2L127;#z7PWFI7x^rquil( ztrYSOeX>Ub0{U_Q`D6oW*Pg<25X6D>-Y9DWAj5Yh@ zve=ULVYsT%H`0^b&Mab9z~NgYAxTDi5E&%k3zePe)*&fjV;svAvReEhCkMjSAY z&2zy)kc-gl=*BLc{9|YoV>5$j$K#4gwnO$+ZOwWshJ2Bkenhqhg_0G=M81%pJ7LCV zV9NeJy)?A&ta0rea5r zP7T{DB=jR5&Dr=mEQS@)=G^Q?0pkifk34+fzP}ys8g;cJ*EXot`eoy?8SBiPz*ApP zXWP@t++VQGQX#WuuuvA+Uzi*xSZ43B-FVzf1lY``kM1I~GO9|pbCZZ>k*j}XzA#JO zK>Fx~#O%01$`V>=81fzgbHwmSONW!`C6ZJemG%%g^a@R95c{C9B{-vn zaLPS7-JGl1vp;`8bwWzz>uTdMJf?|&mF29B#`GSqJm3G8N%omhbT4*Xh9Kgg-~HmT z0Xr|XjZHD2=^;Irf1e@&1AxZq(k8L%f}~48lQJd${(#1tjP$M9I5Z>b5Yu`jp657& zh&Ab!*f)4vl8F+e|DC0CyRzqV}x<6 zeOGk6MFdtG zTQGh9zI-Wo5N^Do5tWf2_JCD`+d(a{Qfo08gUzXM8|a9eFQ#FSK8yb8>FOOFGXrAM z{-?d$r`9u9LdZtgsre(Y5XL#kUH=kd!{?&dS) z@rP8JFa5MrD|a5`)mEi)8vL6a$}$svIQ92})v>n7;jRL=BtZce|x8otTY99kWp5-MG=4Rtp`La zS1BBc3lZCv(pJKLWCr!RZyD{XX3M6!Y{1H(i&961khZku`b1m14Fxv@*_QU2d2j4< z_Wj)azN39(Xx7LqmUXm5&sF3zZCmEXAVjgK^7>Z z(&vC2pu+Mqkh0vWL}#J47eZ9Z_TR;hvvq2j%bF^qgl#dyeKM+RWS^C1OOJs5pK8TR zQe(uDsUr@j&QxM(eyIUm*;tR~$b&V@IxNi^lFnFNqA7Dtv*qXA;Zw2YHq@;GSVWHa zxVaTyN>VlX!EOr!42dkmCprqvKIVc|@F#7rk@`x$e$MzmWIH{3!AF|tifZj)NX8$@ zVeRs+mO8o`w-3`ykTYWJA9d~Qj~H~8yx6YFMT3By^v{$jj(UnOuSz{N337FGByxvl zu5#|zM5IMd;kyTEyIwoOqXPQC<@ES7PaCe3_V{k9EXiJ`DveOZ*Y1WyxqZ>hkrPJ+ z4)uvevD8^ml4A)os%~aca(oHSTkn*bA>`Dn_oR$%_%_GxU#i+;+@KO9tsv+Lh{xWo zw%<^@3z2%&Y@ZOpx$e1$3j_B)AuX;b7k7lZBbwe|&J^%6q{an1P1l5(HIlO9wZV%p z>awlk6BmCK$jvs`Q{fl8%2m()bzkA0e#fKh`??`2>85>I1NQjH`nqP_!_?VFcpMJ? zwel4DJv|Re>eIO!^F2DbNCO$op9)3Qz>?37DD+%%Fv-PA&P6Z*fpH?nFuO#$pqNbh zPF9~Fqdn8|$3E0fzC!c}@N()bn1#hrZ+5q=oi3cJkgetxOC;|EOcC1!9^}VYd>?%1 z!5U(0Qf62!yU`q?%C+u5uA&L`?vh}K%`i~i8;DYa$fPG0b7yW9c}%)XX?#9JvaRZL zC2cTIPY_hh9$EmR9IQ5dga3#)Cd`+ zfs;FJAPwDjle#$9J=I^xfDLyzX4pEO&jaA6z>8ta8wl#S@D zK34iU|3ebJv8G)`8+bn>V@~<9vNOWG6tu|Ak366|bgV?+Wr!NZCzR8+L16M2OL`Xd z^ofTr`4+L*d;U7gv~h4bInv6-`v@~30LQ?yJ7JIOmK=u-b0dw2qoqX?ZhI z-P%}(mcV3Z*YAFK>6)1}u9UTHCr6xHcs7+Jt%t1Q7hkJ>YjR!nmDI|N$Sb`*IReS$4;A8T>O&oj;R_$P-OPI*^ z!aT}?m)wIvI_7v-M6Vji^RSf_R0O0AJ@WTXHj!`>5_WwMRVNp2;g;t(#nN;_gnd^Ix+@(tIP1BDBCt>_PEFVSz_2Uu6vS9#eb^Yn^6BXod2G|gKi_w zXjDL;J4X&E_9EBnj|1PZ8Y|$SF^oGBvm8LJck07WbuU(c68qPDDQ& zdemdLH5E;(S!Mji6bAU9cAa?Sj#OZcrF|=LKm18V%xB|#TeZThek7WV6%iahD6&zx z_wFQW+|hPD2TH*~-?d0tE7kjPx1>5AO-+e#EE$fMPb6ISSm`^h{@J-TF-_fIYHnfL z52N!$8E5IOfC?kw1_>!;q*Is4k`!d|^&M#ZEi2{6 z*Ec1VWHZ>o@Qc&8PL@zjU8ZOWHd+}k40?e6L&F?$h^8~30jr&o8-4Qlq`-D+dxa7v z+xbkha*_v^hDxk0J{tIps(!-iF=b6QZ;$roe85aDgG}R$@%Y&z37rtzmH;c5Vw`c@ z*tA*(5DqFS+O8IOI8IH*DeqitsfQIkYJWSXO2F)^g3gbH&_q$E4eYRM&qnQ{tet%Y zmVm}gmSXV;Q;1fz`%rVtTw~-@Ye7&CII~y*g>-D0oeQepixM;qQBAn_Y0=w0m`8L! zBB3TF@z9@}(ITeC=%`|)Zywvp37IR)Zsi1?-1uwk{2h+bZZ{)relBC%OuD~Ytur0Y zhOOrOCfRN*vXqT8ed?~WXz_Rq8#$7Nc;y&KmA~nVo|FQoO7$iZ;3z0O{cmpi_^qRQT?afp>owY_R0!kcPo%Q=>p=3?2a`FvXkQvY&t z;QUf*w0CdD@Sm1_p$)GaezW}D{l_ji4CEsNLs&2;#HbSs4Ll~bq_3-mV%rpUXh+Mb zM3FtiMHEo;Rni;l5omy>HzYM!5hR0KVLK4}P_brC5U*W2_usDw3eRB0g-7Jiv5(gq zofUAI0Cd(wJr%Y}CeMVYX|G&M04VI5=lVLDi&E^!h(iZkCKsWoym9Jf~9-oSk-$B|VP{G5Xf_!Y_V$?_H=8sw!Aelqh7vd{cpi;J|nud>4o z^GTG>0uZBMxEz2fOg6n|T58m2U0>-lRo&=*XhgQajUCLPfHDF5@SAuBkymZ92&QXj z&QNC~VifcB@pkXkvFCdB&w4>n!pZeC3EWNaxlp9N=FW*fmJv#r>gr68Uoc8F#RQr5 zrJ3&`J69i~h5#~#;@T~=7%N>WvBO)nWc!Nhd0b$`1;+M<5Dd9~N`YS~b#oJN0LbEF!r(4%jI+8#=Lm zp7L$R$&d$X*>qT4R7slkueIKAEd(Chn357gOaPs}lJ6XyHq}DTy9u3wP~&_7*{Gq?guFpMTiq9PSBemiG{zKPxY77YHufY3LNwE>QfnM zJojcDVAn8Q@Ud;=P!{ zQyda1TVI^NRv}o3TpQ}G{a=a5)3b>+AU|!lhHA1I0e8M8+%_8JXjwn$nYx^h+f(nC ztXqjM>>Np9NG^7u@WkbExuq=Qa8e@uM1&TOsL5r=$OJQ7XBwW^ep~uQ_aA~n*cG{F zATjR3D@WXiQ`E7d!~5)E%^g)-Sau!uwL_fEAbYVNH?L6hm)f=q#Wf=4y?D&>M(|Xw z#e&jw%on9M?%zTS*S=ELLyViGBRyQMD`4@$F9ht0Pyft>IyJ}~z=j}$O96!;Esdal63*cq_Gmdqx;&YdP>=IYG(brfra1CuCRp?fI$_1ANUYQwyM>_{ z>}T;Jv53mGnxq%7I_7jtT&Dq1joUfX`;EN}1($-`Suk!XJ=lbqrrSGgsx#2=$37&=8>=|~S8m%tqVeLQM0F|ME4KeA}= zgO#PjdY)cRvTg0OIhqcoa9`?4t)Rxt#WrP?Y?2CTVfe9?ZbW7Z6mkn#DbvnA5f^j1 z&Z(hLisQx8dyh*sV}5jNKd#d%Xo3zIiCO5JmIH&Mb1$7fecKepHfB$hT)<^k_Rt$C z>q6dRgF?az)n=67&NP^ct)ZZ6^q9;llaz_`(%rWpBU>5*pv|T$e%*YU!NC(^THdkd}&SN#8jcI!o z{tKHJkJi5(NvH8_*koH)IxoSh^(}E`gi+{!jUpe#YBD~A5+L4ZH0E0rxV>m(Fw+#i z3lC@#b6}=WRG-eksW!qx$YKDy&*FYb7XAyuZ7H}S$-D&n>vgcUP-=IVw;IA4Q4rpx z{a2&%@5z2~1fmVTcwzTh&m%7|-Dw7jxI0`_#@lhJt0@oLQpcEa4OmBp>;VeJb9bV- z4#tcH?hx=(#Cmntz-ej0N$Ed@RZtmGl9^QS(AOAmtnTsH1?+I{XLuAEan4$Nw$2vZ zGZ(bFUl@trJy99}At<^+q}KNBT1I9w;cdcoC)p_J69K+RcI@zsvks6>NM zI(Ku*WOD}d1@{YtziXT$crP7tvF)pOqQoI4NU%~@Ud4SW2E_^Px8&69oc)qXGx*s}r|?Juyp$4! z31muA4+_@&u`3l#YY~pv>Xwqjg?9Eh2el99j?uc(^iy&u(1DR9dMlGugpnYJs^i+r zL@c*>hW_ORXiBG%#WeeIUX+}oHFAP<~CoeJgs*vBB5W+WcQtY|uNYJ!(JLAex|H9I3a z+@4dL;y%vd>kl<|c1Ig8SrvN2 zaE+eS+j%2a=k*8#oDtOSJ#WV|?>J~HZ%pEtuw^FHj(v^x4<*Z_!j#gU)UUw2LA6TDxAgQxbQJ%x-tap7<-K~zhO1u&7 zn>wvkHrq%Y1^pC!q^hcirKqYK)_ZEg?vPAQC~2x=k9aP^)7nONh9)u=O005keB)Dh zoKw?U9ErTlFctI^P)1Q}M{2nHMQ!wPNgvun6=IL~fs)T@AM-cH7{3kc@s(8NoL+6% zP`+E=ZdCh0aC2W!_f0z>)TAZ%rRs7U7jwHOShrT<*0Q&cI^@x&W0n>b)+Potz8#&v z;WwFN$5Kq3#bofdf7hJ94TT0x8-YE+40p+owK_%B$1=RYr?u~Av@txqOoX&=L zBXVl4Xj)gUz8K%xY+>BI3yptIz*N+FNEZUsR2BMSJ-z{*G#P8*`?D0sXhmMt*YEpv z6fbJCEb=A1#_hCx|2z*6or*-vmaWT~e%OQQ4$;)s?&hWs z>dQ6%-stO6eyuJ_erI?AkL)fQf0@ro%D;n`VN1U?gBnNlp4Ln4n1SRE%?xhAP}f`| zLRFhVLl5l=US~6r)80q-R(^;rKlkIy|D3M|qaG1P?S@i7^sXgMg^_Qr^!nW2!K+ikbZR3a&IkHSj8u-_20k7*Z>eY}w1#DG$8kP5FdAyill>ZB zIam`viM*(xe4ifNYGQk{W1Cgku55LX!%vC1mO88k=fzSvM2X9htH!ZaW4$SEEkS~fIJR@e^#b9-%G>0^A{Ju0HXx`e(III7x`3mDucK0qr+gz!V_Rp=0p7BL|RR< zgEo=)Q1%c zCXWKEBu_Uk19fTUN^lFFOD>;EqE7N-a<8lE9#STw6*Z#ArwEa{?uJ8s4SP-Z1*ubs zwu+qERRSR{AR;)EA=r)_Stk1ME z#_k#6ul`>M7Aq2<>sBnX5p%w(G(cO?d+KVD+;*!gi8*$K?q7ll5@T)U?7p*jhDYP5 zDRRC?k=Y;F zIoDZQ%)2DLy)unhsExS+Ej4h>NTar?B{`}>>q z%FAu`xwX1I>$5%UIx>}4I7@2<-waA6Kxl94i^s?4-&N8>$&c?JD;F0UD+dsoz77Ba z4*WadkQVKK!+?N7^g<8q;g$!B6F|Av_iuqm9^%h5Fw7o0$Q^X#ePr1EJs`;2oA58w z-;PK?6l)%V7XTSNe=HQBzxxc6LfhV30x`1o!a2QofYz>80KN(eh&8)602*p}++#Cf zKyyt2+<-cWnAg^Q06t~75D>5Lau95gjRtL&;9Pd+7hs}$AE_c`B^5u ztz`%^QvJI&DWszlfWQHBs^$Yl;FgDbu;t_ai&Fy)ashh(Ddh+taE0sJY;e0jVg&)n z`v_1$^<@#{Z~xPe6JYO;kXu$)hrkc;1_SWa;&kwx+}Ae>`=<4dE&7D8cM9eL%t5dL z0OpV59|n)ZpB7Dy0O0lt0QUB+b*~2*nv1Uw-w*_B9S}nRF~dKP$S}7LkICrg7RTO~ z1uwww3$R5;_9&!G_W1dehAH6 z5U~^BT~Enq55KbV-`#q&{nVQ+!$H`dK7m{P z^uhXFV`G2-Ui>l0(_@Djh>X4Ua}FbIbQ0JiVgO?3)A*_@@v65RL@|059X7sqKe?26jL874Q=$0?>W$ zB}McFsD0Q?puqQEy|R<|1JP%7cya>w4955P2j-SOD;FMdZe`?K&mREDzO^1WFaYk( zuRqXl!0+zJ4hL}+jgfheAECfS_wQqE_AfZHh<=T&J^orR3@E}g*H1@Cz|Ai$6k;DL z$i4r!Q8)lkpM4zm0m|E(Me(JaA($DGfT2JM}pyR$`+}R1v(U?*mVYaW#VI6wmN6bg6Tm3P zk(`z?48&<11=Svo%ORtZhHDUMtjgp>R(z$=;hM?2Rxb(SN5y20OwZfGFAW@maW2h?7f*wOg z$B5~2YHL3QlF6RN<0ijT;Bg1L-d!>20*)tH4vaUurpxSl=C zTUoulb-$eRbbawMWW7=w+R~%W20)Cu;t2!-0Oz{`M(`9v&|1pX+pOnU2>HS%B{;7$ zi>dbK)e;D46UyZR-*V{XvIwcq@P?6BY+RbYQO z0GFK8>^terxKO>xm|9cl-OMn|WfWhwh<5jnW7}%IQlm@X$r_#&O!v-`Zp!;;FINkj zvQ2>%Dr}|qIYZOX2h*SlZU}D2P68EW$p!S9x8#2=R;0_*|2a^Y1MDK z3*lr^ckSP&Ylrdez&kar*)6j>zRTRnN&yJS^mQQ6QMW2qU%$EM9Uaa6ZG=rx)gz+kVKMWZM-o#0)mgv3s)#jBE~<_RQL~v_y}@ec5I!G= zm&5H(mg^$h7{K>7&fj(+pM`&=iOyA^{%hW1D4foxOWz%4PDsTPor_D$GOxh1_(oZ0 zLOb`7*U^kqk#G?@D7VimBEjX{x3Rr1aJ~yS+}ZwNTO}e_nOdCYsOy-uj>RAC_#Q-R zLJcfk>nvxBSSIkd;B@FWM3!>)MM~n?9l(qPL+)n;NnWvQYcd2?^zfVk8ur*3!!NDS z!(Cbr-ySxlr2bGn(vYXT1!}2sqq)jHdW|d#Fgc`L%^Y54n6Zp6%!m8?Wprn-)>GJR z<<7$Be(GkP9y17!$vT#552vu0WDy=l@A&QA&gZ)VTc5bCP#H{A=DNfEAX-%|H%$bnP&*BnbCsCz)zFx4r zZ1zcWiioma4Oj8r#h|eh4d(eL{tr4cigyveby=b2?Oy3my*G>~YK#|?spg`B{gl_y zJDu-VSKjj|kWM66qievFL5ZZfFjM_d2Aoya#%28RpV=Xe8o&}TQSw1Wne)jHq4Q{C z_Lz1CM7b{ysBsfqU-iBeCV>X&c-4fs<#c_^rheIP zV|wouHmhpzUFqKV`ldp!1a0tqB##j+$@a)9JeSWk5v_!Sw;Dy$8H70H7N8T&81L1El5BpL+qX73W-;3%{)C6Can5sFClDaICdB=Qm zW6ni==t?f;9^0-UM(>A?tf2&SqbP2MK6*<>eQ`2BuINWl88is|ceD2FX)*S(xd+w3 zr&5hxD4yyEgd!z!)3w%!Su+oSqLp{pYNCg@>ujpR;_KL;{B5>ljg-{Sg+}c*iqX@S zJ0N??(Lq?o+wvWB%RPR~+jebl3wFnO4meUB;qr*_6?w`W3njhwF7pYa*|&&y znph{_^_eB|X1}U#4t{LR&>>AHmX}i{+jLK9K11TD+@-2i&O;YuwPXA5hI}F*uk&Rt zWF{7*7Wu`wyVq4Z&5`I5-cdGIA+QB_>ky+o;lT%6t`2|4eHcbyut>10NZiI9Y|B(91~){02&cNIcuoW zUtQWw*UI^;)Mt$22C6#ounyp6#`40{*{PPVnnhGf25Y1P@i%a#L}dm zF6w8Q$Q~suA5(*$>UpR!XW-a&$R3+JO1w_iVfplPKfCrg+^w*xfryIVI)U~%qR#Av zj~ZmSn~Kk}hsHjfae_7M7lp<+Hf{2Z!hKW(bv(TT`Gw%4;|7%XxEs;nTpf@~8oZ%5 z$AVjyzu~d2`*dyj4YT4{OES_p*IxCn#(BHFo$3=mJL{tamnQalh4GhrwjW@}jSC85 z?*HriYD>_3$o`=PK(J50+0`&VVSwh+!tMm@+YhyGfea)HHt zhULD3@w4fXaHI$+oGEnp9HkPOYiHyZdk3Q|;#MHF)DjO0ql{XaV=u6DI8DK{uEg#g z)*sYcp1mi&`MS{Sj4r3za^ifclDrY}I58@;<9oqh+OtL##Z96N7Gg4>cN- z@g5k^cx24!+J1|+VhSURH(#$fE#r%^M}LY8Wfi1BH@ zzya?kyXdBv6qTv!i8MtoY-p0YT8m4pya#`71jD5i_DP4F#KK>_Uxt&L<=3M0pYY8{ z%?j@)aa7X;@x<(jtHBiYeVrAR^!j@*Ge&VWXRyFk5cq;Oej>dCcPW zbF9-b(`##EtnnmOI6GHvH!eRmVV>TtMyB^x7^V=qMiPU=z^~}&{yvQBGU#fSuV2sI zu_`#%H1%tN;^WY=TaFz6zAMYhx4VSHI_{ZI^^|k29ImQ2!wjTDRK{*ytiloLX~@aNcXk@Hm@=S1bv=Al>cNYpG!*SBQ>86?nIA9bBreWdh|+#r!{ zjH*s~Nf+*v9^1wga}#RzEZaOY@%_T5)aYjpEj9!pIuMznB`EJ=bkvw2l4je1cy1d) z_a^%99EG)v1_?$wzWp`7c~+Ja#S>z8;O(e(0Zl*<9pOsr=YwHtcbk?Sbu`d@S4HwT z+>L*3H)$elx*M;3)GqP%c!{AwVbiAiQ(@5A_6HXOM+bujZ*O&>5LeUFImNr~kUAZ_ zX%3ka@1uiI{Tr1IY+m)&6P1P=TT_;dYf((h+D%Z$!(nQypd&LK$waxis#{Z&@PrP+ zP?8SjwAbL83kP4Co&%)DZ4Zq8np3S4g7|rdhmgUnRXugiF+VEbXrz1O6+XVcHVgPHp@IFx(}6kWHcscbH$VU$3_9wUah)ZSK}&< zs?#0494gxUtf6vroR*b~T}wXGPub_yB$Uggaql?iz+RXF+^&LB{ZJJwUqKof8YHH0 z(*UR$d=*o(!yX3@FSYDUbD>+?T$EPt64`zy)QAd*u43!KgXa6?qZ3uDnGa|dHnvyh z%U5a`Zk#Jm8p6R>E{)dJyN!|9_~w=^`z$M=`@Gn9#ugQrJt=y-h)aT&3k*TaUYKX@ zZ=?x>TpJ@+cFqsF_Kv5jspuFz;1cuR58IeLI6GX|ht`-LRs*9~k%5Rb%|6BOCWlM#<+E z{&;L)0uU#Pc_JDJ^Cc<%kwW>?pi4qB!VK(jcX|6;PKSA)O!7YKYxH7Ho-*>Dd_N}b zC+)}Vj7E|UibQfBf9(fgoD*dno)|bkNUqKlkrUkUvSC#m&b`5c3Mc?(gG@2r5igSS zk6$w9NX8`+(>lTV6aQj)8U}6!vFt1IC9opmX!W-|lZ@(FAN_^aowB3yN=90AMC0P za*NH__D=BErrxMR+nmZM8ltcrl^-W=4E||9(pFf_hC3`Y#>uJ4O5%a}0s8E6#kqi0 zY1~Sy)yH`5KwZ&2hIEfd2jRzoL?Pm$X4$}@tUawFqOz^2xM?p&4KHW^8*JR2PK|%J zzKQ9Z8)XrPPfhP!d3Dof5q6&=Z=OWS$Hbd5+{@Ne&kc6zaZ%wo{4$W(^#t4%hy^1v zo9)782IX#Xw!#H)JLyh%H0jWCEH>$@lcaDMy1xM(uB=e=##3K=STS4oJk?1-#+0Xt zG!yGuf1@t+vg3BAmPoVr8U{XxoE5BP4tBCJT^~*haCli%J3!nbKE;H;ST4pXT9EvD zi~gK)ix@XHbb_H=3}C8ZQ-hHXzVw}YQ338v^;PF`^Y0x=#EHhY??-xi{6<#D$#p8e z_G(eiadgcJh}h0rXcH17RiM$Imr7K{Er$#{ByFi!$Vqdi=P@A!6xx;lEZhd@Y4q=^ z^tdmTv_UM_M?bu!8xB6srXVI`t;)BPGnX23f*A88g^}8wv7+Ul_ut^AA3V7Sg(NPv zXU11h@{!2=+n7tZu~99`tia2L!_>%$jQwU#rH z_z+Af2@+zlv5eb|z7&1*;6x@=a^RJ%jYw*7HhBL!!v#{1dAc06ev6ZMZ0Kmj|3ZI} zHKY?Usc}AHl}ZlndwCM)MWBv<0cas+VyUZ!+sEHF+qyCWu)~|(pFgXAq2Y&x)JH2> zGWpr#F4l;Lkwo5oXKR0^U(te?9&ZG1S>FUG%Q8UB zA!8>}{q8QSgHo*7uhZTljo4^fU^%v7#^Ww=7)UN^K2!y&LS1{kV!Yd45|6abkURG+ zCX2p|3uvT38QSFkU<$B5H2qm3CE#wXbnK%Q;3Og}k;`vnF?e$q>Ue3>hiW)4&AuUc$+c;q z>$8G9AK}dib72)Yk4zk;%AL52le-=Mu*^vTR~O#ND7gd6y*B-5+(|JQV|FYC7u0H4 z*WByF=`G0+C8tB$v@c0(wSGq9K8rcnf|^)7LiCk6lv{xKbm;k`-;=Lb!N|bhk~vt%0}EI% z#6VSwt;pG{T{{Hv7|t2wx= z=`FQ(RLx`18pxIXujji{Jk**^43l0e6sd43UiUGm?=-ajOLCWQQ3G)d%2U+<-qzC0 zOLlpV1(Lw);NZ=7m(g6~lW(B4P15r7j0$_5XLHqz$07w1c1*ANiitYOwwB!MDXE%Y zdxTy9X?s+?;*-Ww>%z-$Iwy9@_SdI!f5fe7*N^h4JPdy0y*OLqZEQUvDF{=&>u_^s z&SZkvOjfDB?HYP6g`2kpo+i$7RNfVn8K_o+S2pB(9HS@&)bEb9tLW^~-G=p(?3nP= znygi?(be0k`en-vP_VmU2Mp*I{xeklNulFgJyq8+201(vm;c$X<u(FPC}q%@+0rQ#onHHr41)Qa!NOXCA0IGbI38y;6$^ch#m7ssaTwto`PX6qWPePX?e69ja;kQYB3S;>g*4`Np6t8=|6_hgGV zmto*!-jnKF37E9kn{(1?GuhX+n$4jTG{+ei>8OgmP|*^tcTH`d4`eO(hPyx6QC4LlFWBP#cjHInyLF8H@YliJiFWa z>@%i$y9h!knY43^Y-8na&lpiM^0TiusB&@rkzB4y< z_|%$>x^>)USA|82Dr3P#xHxCfqWF~AYeF?mE=xR>h=RP&T87d zU7;3l5AW1f<O-qCRutzF0KZJ)(YfVgaQ z^vaYxz>gwd2$Do*mIUaYwvlY0ZrqO2q?>L3u;PPF%Df1Zj9QQI*f5-=HdS`5;&9M? z=vSG#!@!%VR*AbhhbUV)NzQ?7$xbjhH7?n8E60jh-&_cn@DS-99&`=4_lq~b2EmG% zM!O)7YUk6`OP=++goYhWuHIgE;rnpNkbIO}+$@*`;S?Sa+}`jm=fBa_jH^V{A=B02 zLRRBL(3{~k3G_hR`|X9Nl!fiCKr`ozY+WNFtqKQ>Zb_Q!BS-@frdt9!RU;be7|O^| zbOtndWhyt<5_E~~wyE2-wH><*ZG{?C=si30mk!%{@lK(-F>?2ysI-q6~`dpH|L zVLmC=(@esz8ur=%G>+O<^aQ(#bE<*L*p;tnofFK_{DL||A7}DI)7sfIYy8~ZOM)*G z1>BSgHB1Gm^4NGw8=pqCRZd9GTJH}q2v&vuvj|=Zo9~N7vI4O$Fk778meee;Io=|n z#lX_BGRPDh=X|#b@rt=!aH~(WS=fP>=B6;26-&(&#T1FrreB3L@Z`hP>nH@>MbFJwdQR~T+ z+$Ip^Cxi_3K5_0FVen0-4etI%HA+N(aY-5KNyv46Ms#nrT(!_66Rpq%@Fa^Xi?nLm zffe?k^@U^cSfVTboW~cBkL3I~2Rk-u%DAY^><%M;e zdesrx{j}DGH`8`?|LYtLEJ1p}J?wn$5%ID8e{d`$Yr?btQdWoY50}M>IHj!Usa* z`yx|cWF|l)&}Ggz8*f&ToXyljJ;XaTeAYc_wTw*4zTaG-XLX#+0|;l5cHs3*cxBZZ zd%B|-KH61F_4dR|KAACwyH-K9&g0uc3lcyPeiwbhDn)cIjTTD}&aMxqB)?QTog6eX zbKWR!IXxY(k!~6i3d&C~?gOlE{d7(FAGcqMdL;GWvGa_ZT?w9e;9)aEOX8>YXkVDl zo3)hG)OzQh!nwX7f#aJPIWEg?{GE6WT4 z!T?9z(o=>7UZ3QR=i!SgOu4PUY=9i;Mi%N*JUwkl5GyRvX&pOYj=^z80~-mf)<^xg z!q@Vxv#b(jS3@x4o|}~8n<1NKoNu?0D23N`L;(%CSk7{|NSOmdyLtUc2=4QQ9)q;z zP%y!Ge@NEG1=PHSvg5|D{(Kurl{&0eimDzp)t0LJtuD{jx$7cJ<%7}<$lL`=(-wpd zeZp#%1k&Y0h~^u(6Wm$S3R81-O9ocldYBayNSZ57Lvc>jE>AI{wcf~&U04jWUdJ2?m!uW(529GXMlkRh7INuExcWI`r@=05sA%6jQ_q`oY!#! z((-i7(rU?07WZjf_NC0Lh8Z*2;P#UiZ+}~;^&KW@Bh+5^{uo@&Jl5kokh*&<;&Ta_ zm$GBV#NFVI%ug_v{0QKTQ=wbEAK9?LC+TXR?8OQmuA*(ZC7Q)4HXax?SUSJ$8pP@` zv9+6FX-~{6JjeP+op1T`lYLs29on=<>NTD*+6E=99XG53Jrug!Q>0icfL8mi4HC{* z>g*8jfmS+r z;62Fy-us=OB25zHvJ1Tp!nnJ+Um^|Jal&-#^G0Uwq=!$qm?x&62%NCxGS&QTr}3Ho z-1u3e=(2z66RaY80pbq!DDe9_FVDIK{_mQFl?gYoQO#g}7^aEi=tfD=j^Z{dj$}Ay zX0nu*Yi+CTK6*wISU8s`qT#7rhr7GH3>S)c7}>dOID>R<_zsR5%8C+CJ!8SvrlXe6 z+0J|tFvLh2g=EeZllIrhrEmE=54~w$iME6dQD|ZM{qQEJt7FXy73oW z_+yJF6_qnhrmTG#MFNMzR2x>$>|0fiAIeU8Io@FgJl)XRK(|N04UJC&qGV7Z1kd|) z%cyd~3Kk{Q;as;#nM=kk^^EJ_jp=GJ>Plt}El0F@Sx1uXlq+*xxLb!9OljKpFz{;q zleW^7H0-+SZxOsOk@PT;;xT=QFBGIhr3OuXH1EDaDNPP6O8SC!a|~9KAati}GMG!s z{c@=eq@m0h?{A*I262VGn_{ANvzt`HU-MRh+x;&&)e1AJNvxXk`TM3{NiER|=0ft* z;EO^MAJ00=)-GeHX&nD#9*FC34xeVE;$<+b^<^Er+hg)*)U&~ets25^!o6Nst~{3p zI1uD$kal?T#1^Mhm7zx1{>75(DlfnVzK@G&v`=;eZCT~#WKJi&H`V9;_c;QQ!9zgJJ4Qyb89l|k)2H&=hHso5~;{}pI z2-^=#xJTlm!~eI^4o`qvEX-RBfgyA* zk_-p5sNe}H;V+LQdEP@IQ>l!I08-4R;F&_CSWG3JMwAbs*| zajNN6({uKXq)V$4bOj||4J(NnHK2nYI%o_)LIaHK004#@GN?~PpsOpyJPY}P4)(As z)X`DYfRXVhBJU_P;NUKe89VgUT#vy&Gz5u&1{zFa986-OPtOkmmh_8`ctr|KKE$&i z&JPV`uFpX3hERvJIx+@pV-`1L_f%I0z$XZRkeZqr{4EQPlC5BC4uS)0KH%_5ZuT7u z(T=R|FOsjop68dmpVl&Vpluu++}+)sZ*S&CzB+T83IK91cytZulgu?agB$|l3kzdD zl%wEB8WiXbDCE`rg})7874;O@RRF-fA1sRXYab1dWdy!nm?Q5Wdx=XviwzFAk8w;#v^{|v zH5cYJxFBnf&3)i@X3wu80PlYU{>_!kH3)kX=oHpjl;ayi{#*s~o2)`FPEy^(1Qp~2 z{&OjZc@rwQAGafRJ~zW@Sg(uG*9Wb|3}*3V1yLLpHLnA+xdL2L`<)gT#{V~PEzi!6 zLrOzPND7#*4VcU}sC%yFA%u^~F z@c04$^Y#N(fpJxdZK?gm^w4J%8L4j9FDH!APD?`y1`!n@0hqWr$luRbbw0S@*X931 zrh;n}1zP;a9K~1S$8!Dg_WSYYDFpCtMq@**+f45N$A`rh7BPhI&UWx;SMn$O(Fggh zmhzW2`qxFM0#8=9XYjlC@J9^eCd&2kO|s8&6)<$A2OZ@Gc-mJXTF#fdB1pJ^H~U{X zVr<}nSH6G!pv7B99R>>dE2wBkWnq`Rm=-In{;w#V?|ny4)=AJvzEj=pxlRn47aHuV z4r5mrLhSo!2$ybZj}T>-=WkmLG^n4*Z$nyG8_2(_W59=>zB^NRcm$Bopc_Ad{BBPW zEI1#78ZHlL-wX!8y1_PIZ!J}w&fCbF z80pUjXdfP|N0ys$$aKl>>;Pi9GaZ$!p5N!`yH^jRL&1k&URe zE6axYBeh_ol5>sW%SN2)8;jC~Og|<$cm9c_$rz9Fxb03ig3;heQ}`7dLs?9b8cJd_mLnB=dFALN9xPE*#sGO@YUwa_ zjM^=TcjO_s4-8T1hucT7Taq4}@#;GOus`AA_kT`M=Ud3gLX5<%XnkVV1UEaDLKlz;L1Xr}X zGwXso+mb!wGj4$`7M|^&o0Nzxxw}*He^m3-KSw;5b??maw#oUmNuzi5rl}+QX zzGtj8x~QGig0@>uFbMBd&G^tSK3(5lx_4cj?0-G;jK#P{8+Y6Vd1a%_(DlN3Cp}&I z>b_HUhMyt*$!5j6QNek~RMnmFa!wbk&TR^TytmS+N25>D2`v;Rbi`t26>jX|QgHaE zSH)9Xx2J5bP2>czOkGJ^<2WT#vcJ_@WPYkCk58nLN{=KU`6OrcsR^Y2Dg~T1LCe-< z$EoO0C|R5+`0zWr(e~KL#Smm3T)s$bq_ZDG-8DPLlVnbAng*N#HaAt>=k78sx$e#7 zwyiZ=FEn}~jze*4eO5?kJ`NMo#oDZJCJ%K~quDs+`Qmoqt(!RT;7*<(0z$$%5Xdr; zE{$k;#s5t{l-b|!IIRQ@08w${FAJyK9#`n1dqe7Ae=yJ?ZHOy%@VeiXw)7=SmVF#W z5%;iywRS)eD|E`uYH@rPH%C@eWK7i{h758bWiEiuJ+NrFi>W|TJNE4oU{pe0VT&lSGP!eGq8hD2rcjWVvv*3njI5s z!2DC~SQ0_rFEepy_%4~$_zb*1eJl0wrG$j&{{&d>I>nfS_&n~EA<27FJyh&LoZ&u$ zI=~B4sIrFtsDBnxf-s_gy(Bw{9us@*$RrlIsw?iC0tI&NxjAv8a!m%FErCio6)U=#Mx7I7iqxn`mztR(6~2H z9Em|&#t!AA42oI;$I*j5#<-(TV9IP4Gu!}+4~8(!JA&$n-6W5A&yk%AxM1Co9I9I> z4Ww1m72l{&@Idx5#^!q&GvxJ#i}x7Bw3k!0K>zsJ*44`CVgmcz?+DjS^b*-o-$?Ck zSAXBWB#u?>QprxgdGUxjw}h&?wRFY@pRax~;y#vaxww%;O-Pu>?!mHThMP^?DMhSc zJ1lQzVw%J~M-q#RUEgGF$;sRb?O<8%yKnoPO^pHYaDbsvOs|bijI#sB&5ViwnZK^& zJJ&=40`0da;V3x(UOaV6_zd_Qa;~P;Xmlf6?f@XCxV)!V-PO#zlno&asnpC++AAqW_b@`+h%=wvgSbG- zWrLwZ4FqjBgBkf4Ejz)$Ya*i~AHo*^MjF$j+J&x!@_=hoB&*Pe$8Yu%lux53GWTJN zlsgXMf7FJtF4w0<#f-)Emsd@eSbf(;Ku}+X52O!7d!12sF=Diyl4kl0qQw>X=Pi?~ z76tYU-BvDn#!hSmfy92)!KR%fnNn!LLH+w-A+@;uieKBacKu+G8)+OCZmu9u%FjX@ z3)(ht?Dg~Z<)k@5bEAj6m=J(RKZCm)KhB5F(o(B1!>E=jMW4cplO(XV6&?Yn;iTen zc>kwj_t)L_D6#n<=(l(Kggi2sZt`<2i*}b113VgVdv;YsC;>I+(r#`lG093+5KSzu zhpr_jN9+VP$8Ewv%OP-o92uyf5%zav+fyHh?hbcVBDJ6hmb$Q%H=||;l%f!)Tk5QO zd~SDIe&=hp4)N<*RVC<<7G-c5|CH(Z2#ES|u7EXAwBZ3-Bxgf;!_3@V^7(}?4tqdk z>KRxCS9QE^XTwcC%{p~9+Fe)XG{-ahuBB>%ky9cv$VgEWlIx}zs)uu;xUte^3dDLG z$)lScD0`fK5l^$KG~n79Fm!X#-KEOM^7#EpYzv>=rX~dWhPu~YKjZTPH}p`|B(~P$ zc6qH;FgZ^QFMGhrdzP5wnL9;^Jr_YJj&+BMe2uwB%+JJx`MCuqUX+CAo68kpnC1>} zpvxG288|HMxGb#emu8JyT=n};i;sG?fmGX@lT}#O?=IIQ+_Ty4UBVKL)=r098)PHz zL=yqbZzy#=~7%*)5c{&WpIqTbswsPpw;1s?Nf;U{~E|`;9W=?NmIksEvq1?gb z;D)QG7%U91N{*+LcslD&*JTqr%w2p+0iQN>@RN@&x(TXpZyaCt5eEhY=NyI9qmM3R(B(0kiQ5u@MO(Iu4>w;ih?6;Gx7=LGsUX!f1z|u z3zT>{m^x7nc)hCCbm;PhTW_T;LG%Mp>8&lq1iV339DE;78`+jVCRr`DDf==9gWUwN zxO!gI#TujekBKT|UZ>Iz*`|lyh~wU!dLPxrDl;K(HawwO6>$+t;xx!HP|+8gl^M*g zOD24zUTIH6Lzjzmmrn*HZDFp?gQIKe-~RU5h1n8!erf8XDT_U^68*y*lgt8<0RJLG zC7t~iiIYsjm7dr*%(~qQ&_$L6d|DPjA`1>0G=>hhD-~3YT&3!{B#1E+v*1LSslRL} z!_Q+bAC@S}W@b0jt06>zHNkk#K%?gT;Y98DQjlXN8?oZ9f1J5_rep#+IhRj>q1an` zFQe~KdaLCsnbW9U)H1Qzq3>iL0W^7y$1;RT88!mPy9S)v!pm$qk^Wl!SChy&D;$Ba z2?{nLE0DEY$ULyis+skpal0MfK#hSUAva9$9*D3U*=ZB}oclUF#J`v$0*t(pbuZLH zd|}W_Xfmo->GKM@jdYvOmpM&qvqRFmClLx~w_UAW|25~YUkW%LAM?LNtMCheMhGVY%D{k1+%JODY9Y>x$Yt{9;nZGB%R(J2(S6fH#ZGt#F z_>Ks`PffRKPAdo%Q|&Gd*g`G&SPg^s!Ef(Ca097IVBFfbuO@gfY#YU%5&vE6`Yk?- zXl!&Jn&J8;z3ESBP~0|TaLVZez{6TYW zUr2t53@j2;VLx(0$O4ajDOBbm4f|bgAN01UI!L@oUpbmoa=9KgC{ShEva5KBL$cIO z-VcwDDa{X6Ml9Ic{#3-Myz%z?JrNOaS<@Q7g^(@>EBzNSe|dD?p1U%gC|sC}Iv=*K zHO`0BAloC)*^`sA&K+-?@SsPV6WX2eZu|T(M7dl+Ak-1ft~wAcVG0-~!70EuPd304 zKb^fSE|6ny+=}a@yF|YUc&$A}|1rVSQzT%t9a} z3!MXTzVKw``tm1BC~<)b8sUz5Geid;yV?jtJ?}Dz`{@c}CBZOG?e*d8dXf!^)_2IH zEe(+*S*_nKp%gALoYx(61WL*qSPbZO?XeKLn^!W5snV@@vFLAkVOkTpiCSPfL!{yZ zUx&s6cNCYe^8$z&-JAe2oMCZx*}R{v1)0pzT_wNs0B4Mvd;U=K#3>E!H>I(e4QRRB z?hk6o+Vgam_sr%Tf#8fx3SA7FnRA^JhwoHF>4x>>I%mhsQ|zoU{`zcI-@|NV&4Yd7 zjnlq`SAM}>p(r7)qd+T~rOmnTuTRg$yX$RgTS{)CMa9XAjAjHM!tk9P=#X^j^+2SP zaqYPPF?8gcjFwu(EO!pq_+fU}Nph%MvT{w(H8~CZ#lS$cCu@|gg0pRmoT`#i+w|(K z=5?;zl3|vm?Kk0+LT6-B5I^4)#Vc4_eEe$5o1mkL;p|foSaL{pL(ewBvQTZdK`;8a z9BL%kRG;*xd{%nKbhxs{{1%jJ>h|e6Ca*&f!%gS)5_6vFl~t`d3GT>QzbW#DGzr|< z;6UH&t{F35b*@P#m}|c3=EZtKR+g;mC9%GCFHv%= z?3?aotPSOMvy$gFEafnDF5C1TVqJId8!|i2e0MS^4U!m%Sa-{G7Ge;}+m2?7{fzOV zN**2xyyemFHqVaPrN+r#vRsAEHFWpvi>!xcHU<4WG)6z5tX5qn;ePzl3UX7?*QwMK z?bb}YOS=(>7ge`scc_<-d9Ae!r20 zUTxJt2@hPakpCgD&V{P6i0rtk?LiG0Af#RhMPji1le&d}O{T zRS+Qad-cPaNZewn%K)nRU~9|i2Kt0e+gHIpy-JfN-Ld?}yyUn2UHY=$xwNx(Pf-nMY{}(1!ZvZak zK{lBvB-}}WsqQ9WPw5@5>qRJ?L|$@{fdmjUeHL*+Pp`i@6B+fyvjVGJYS#wQ)t=eN z;E{-RU_Zbu+R|NL!W+axwK8~gZCJcuCZ@C}T){;(*0i9h|K(v_HXBnnbK?l2D%;6) zwCcek65}A&p?h7EM(4$t=v>v#@lPp>y7nn;7RBYOvWW&RSDs=YR*cg~P4SOx##Ml~(K> zVY~ocT4GAgK-!)BBhtmJs{*0x8exUF^v>hL!MbLqpmcF&qBWtbG}*DJW~TSF5L;{= zbS?TWuA_M>wj6!wQSG}L>*@3OmibAT)FWxP`0i&?1LN^SX{PMQS7k}lsNuwIVQ?>k z7&t`&B=-WY4#u|SU1SEPi&?};8Qa}E-ze_)zS8In99+@TjKvRqM&pG)BD1D#5~uWm zT5>{v)~autP_Le7)|cN%*co_+z{D8mGVAie*N}|Jl_jyFc7clak%AT;Ww}1P34ygn zx`v?)t|-=d{uQ~r#eALG<&d=9b6AnP!DQ&|SL|W7nUSriQJ915O^3q*X&KFoT4Kg< z=|eF`dt!UK%<@AwAY+QGfOfn_$(h^$7u#j1COpNY!cqOl%x-fgG)8i`1v-&#t@|lW zJv@3{!njFjJ#UV(7Aw8huJ4&Vzoq7(OrDi&PfBX?pv^w}@a*jkZe7$u+nKZMGHE*% z6({7`YMUOP91dQm57y1nFjVOd8ehC%D_6?3-!bHQ|6Fs!756Ycrgo3!a27gbN6j&2ZK)`(z42IVyn_8g0CT_Ht7vbPEF-| z*|>qw-a=<#pA$Ewp`|IHLO0N4U{a@7hz-gqdac0Gtc$t~QBQep@1O77CUO*P zwJ1L3eP5KE15Rh!pUbvKBS67l<9&^5kEGDbmlg=+SE|C1kbnPm%=WO^)$(aWurToG zFhlf|e}gi$SYm9Z8yaGek4Lm{bi&5Ne0;0mSGn6@>JJ0E|2W>3NFT3vl;Wcgd2kU2H0N;1XXmA%VP9Fbq=39l>7?m_^KCDOCa zrhlAvaVe$2v1ridS!04CR_3sf8*j7bMAd#?7kP zdB#nS+s4Eq?S)g`R5Ka&YQ440=;)Cg+BTQTQ;v(r8a(Vh9T>98?;qa*I=*uc-nbQ4 zCQ+m@NLYIz8kR?D*F?>1u5Fe$z=YwZQXHhEP`JQ>6_Hdm0bU?`l9H*6f;w(HOwcXo z5>hgqe$C`e*hD5tVO4HjA9GuYYy-U;1kuW;U70`$(Ib*rV}O9X3Kp0vW#QXEpEk&G z$e+u#Z#9NdjLJw|j^17+Y9LlWu(yK8G_(=a9KPdpPMSezXOziQ0k5Gl&E;8fG(C7? zcY5>g#wO6cGpul}oyl1XA{T(W)ZAtGd46ZLJRh9(y0_aPb9WVc)|-3QiH}A~qeF{n)s8BR z2q)zD;P?~{c)aWq6AZ}B{k_f2?d?uY?I~YOd`yQCCxRbnA2MiQ_(#PL2M9=bNAH2~ zNGppA2VCCC0p$Jx*ez)IAA98H2H?fRTlfPRL^K5Oi04|y%AbXm4;dn;b*FZ;H=_et zUWM~$oA&bswAOb8s4FkOKiazh!2GYF4Fxs;a7j>%JA7d)LO+g}4-GCvC|>86qMuYR zM3gh)&kqj|ZyTRP#fD=*HS&wG4=Az;=uA+H5X?1G59n6-DzqCLz~y}hqyLv{8Q{^(e1&jTo~`WfwUR)LBESH@gs=ui^Vcl9zz)V7V5{PZQJDG{yXi?wznV7 z?Jevoht{u)!0qVi&IMIpzx}0-;|LiA$R7bB9vyEkC;J@)6p**u4cG$q;k(8dARZe` zY_|m9mi-gZdLN=&Z;bLE2*BiT;IH~1K>qe#DmgrW`FGpMl$V)iKtEh9h|+Buwc%e`S;-O2;_Ar|F+3r>MriV-+CV% z62vev&}ddpV9-e3mKvYkrvio0)xe7hgq24N3FB@#mmtCf=g;DpEG(Cj#kR=mVrR4^ zfsECu&H8#W9nIK4oPpfZ>vevK@(K69NWr(xYs9rGIrP0v8$y^>d#o+QgXVFU!yyox z&#zQc4AQtnm{Q+RD7SmN6uaJDTZbJ+v>i}(z{p-?hLS}hBNIn0*M-8E^mMg^AJI}_ zhkp=B&TKp>X2fge3-j$x8>JYR&~+|J?a{v@BfZzTx6Hpu-(@+df+hyV%f`Ev(jCAN zJ zTM>BAj$`43VRAWQrQsv+OY94fW z21Qw>%(|2md(5K$TVa4KRR8)qSUxjo;=JH)uq^8kZH6nj#zhr z>i#Q+gk_mRM&~y@>zT({y9FH<2PvxE2F-2>@GdkfS6p@XFCc@XvJ`2t$WiUPzvk_F zEX%|RzbiQDHhI_Ek9&LXo`T}dd{AMIg7>7BG{S>p_g`mJI=976xX4W`(xZ2)q zB(0eA{bxF%@Zn$3b*yYOOOQy68?CfA!tcG^)f%a?<(Opm=H5ZgY&1+&5O&h5@;d?^ zw}M}!y3gMWz>Rs_pg)iXi(VF%X;}HH9u>iHptH|(v~b|x*`Z_#ctT3^282^f?1RjD zX%laMmzWRxPsN7OwYM^1Zg9yJ8prfk^rq=95wy0R+P#h={B6Z?jkqj|y>epzcCP*8 z8O*)Ta^Ii7s!X%S?#$*B)0i0@iQ0tQg5kZJ3=9Wy6Fpd$miz5_Nxl4XW+w+*8ni3R zIwK4>%rTFfzpEY4s67ZfJq^!v+f)WO(kw7MR}JpaHa{+T5q?;Danh{b>3Bd?*@SJP5* zVROFA<-jup05UwTZbD2~{EQ^ujz-=|+RLWmyyv1ToW8m^@EOZQAfT2bz(!W_zr}wi z%hs7p%CPe1b251jpO;}q7Nu~%O7;pT3ZbO{T6hL`vrTcb=@0n4PTR<%4jxd~p6FDu ze!&S+)2aO;XrzO5p_Km!0ljxq77T{dy&QI^Rb?U+nyBEpl!POBhOgnT(0<~FHdDoj zxkz6pf&k>|_JxuKws~dXPq(10K?Mw2P`_HFs~*x$d#~gzvKnwxjY}DKBVzEUMB`$Q z^_1vI<)!3mcdC%R>Gt67Fky#!J6%kij@M$L*85+p*_shUXKKhnJTg$yG zYz&c)3WR3MapkJ+q!Nk>$k|Kro(%5ub|fLA@L=aVy-^97d#jWKJIUfpkoEdZD52rWpuT%TaH^j*i?fg9= zP>YOf+%O7U?a(^1iM;0ro2cP1lFU0(IDScj5wn5d4i;YH0(>LGZcXI!frVKQCjt}| zWwoCY35)(LHUk#+TxP@0OFhS6R#>;{c*3cjyeZe&IjwKz(3$P`8>hUH2lOv^pI%fY zuBtK>L`&mICqh`(e0^*Rv`{E-VdhGbJ=MBl0WhlR`DwegG;)1!<3LpFE#!7s z7oR{BjT;0#a!+EEV0BAj=Sr{%+P1Q>EpfEAH z+}I}x3vMKF4LWT>veeMA>snQ?p;$uGj&Y0+Vf6slc98!@3J!J-+i zu#jxi-Y;J{y+%fwDV`6Rj}p6ad$cqc_HYsyB@`ZxoFXk0(C|sh=7!FzW+>YF2~~{a z);BmkZqmhXXlM#wF+(B#a`_4|EDLuoq4~cA`xX%QPLZ#Z^VRPb#0`$7DA|XZB!#LEC37GO@pQ&F0Kx3uUw4mM+|B+!*8xq~D!Tmp*l@-IwHD*?nXM zuqqs9C9F-;p3;yup`T~~v!sl5?hB+XVDa{fVJC|gHn4H~-{K0xplp~#$FoSN;)+&h zC9Zd%4U1MMY7F6w)k|HeH;W9%a=TS43~)A5gs;xx)oZT^`=QlF=5DmJP0Q(o>kf~V z%>rf!q|i50%(UPIkwWBe>mu4Q(H@>{a zGW8}A=}wwLn~TsOh>JpNmnZL0Aj9l09ZtNY@e^JWVlkO_Cdqd@*>cDht8zr>^4(rl z9u1wI0SUQzuP6=dzgRD&ApBmGB9^!eWh9)MXiJh`@%Z1T1&xt0$i*KCpaD3{m#nay zsUmaKqR#S8SKO)#(3OZ1fVXo|bXt#fh#ZH2_q5E8&i)sC;=5%&BYF_l9_HqD(n?j# zD%xe|S!xt(FHlb*4AQQtMJD3U)5`wqDuyMbkLhgo{vXbL6IupQlldicKua1j>new4 z1*p`ILR)-lS5NJ=&1RM~_{j+qv-5?zVWI1!ow0J>51i~fny+a)rw}fCN-HE>LseQm zY#7uX(HwKQNQwsq9M2K)l&<7P16o?#h(!o}gV?1ej%NKy->zuJy0EKgzdb!HX24Ii zg$dAm8YJaB>!Q0R_WjDWkm~p06^^j!eE9_)x*wc+l6R0p1$-egAAvpRT$ZYfEqR(= z#O1`zRqWQo6865gl(%!-g9I@9%-7-C@p)eNwS`&Y2vNBn+nU~?>}+1LqP_07tq5cg znGX{!&P`TIa_7^Cqb6`-=}{&hxSY9?cJhA~4SJQ{L@GPSiwOtwo{DqFt5_b&ZF9SP zdmJaR24E7D?tVTq*FGkQnY&new6^z62nv}#$hyQ2LEiiU0Bu^*GK(>X{CI9kCLhsd zBqfyRXR$a&a<8Fp+ICm26Uq1E68zKJWN}}ea4``lVVa@od1p>L*A3Y*hP`QYyMyO} ziV5s1&9x4?#OK{3zqanZogH;VF`xGNsa#FF5F@hqUL>GSz$fQ!g96rdHa~|eV`gL& z&mEOi?7rISUGcDL8Qw9M%=m=S>9GWx=7NB;o(hVtBnY#7i&E8rs*)Hz0e~}S<}_iK z=f`<{J15sy?8*-?ec2jvlF`-?220%9rlN64kW9*`^IMFQo^Sps|Ltnn9Y5=WCYtW; zFqF2vB@ApyF}=}sI2U7iua%^*N$U1|rHI$u8A`4Kgm<}ssXWL1YxWtz0RhVU1;|M6 zAXs4*GBg~SaKEtcHBFX^bUs}j(9#!c> zfb!kpo}#~qL6SsOWU`1IAl>PG)eX`_mApiBeQzSN#d+6td$RTz0%HO{GtNAh;n>A% z_%j{cDB@<^OZh~B9RM#5`vvg<;I(`lej}R{FgV6(La$pr>fHx`{0?YS`o`q12P+GdMIVW zJr)jG=9(0>655J$2cGJw=-}d{Euxt_rhT&IT*kF-7O9BfRsX1HknDjQeU9RQd4ypQ zv#Eq^tOObH$rQk!+TU1OQ$~xbWs7T2^I5?YnWwy_KTU|oD#h=XBBkSSQJ5AF_uMUD zyq|6JdiOwA_$j+MYt-pQA3MOW>r{YFib#aul8d5TB+yeqZ{@XDJiS(g9s}bV#qLwY z|5IgGBc>*vuT3jXxzWzZsp9>9&5+eHu|#*xpV0+*d^!&rxBGn?;wgM=i+P-T7f zF>%$JxN*%p!8f{l;!T&JdcOi)PHD{9!I{Gnjpwe6Xhwygr#%eNq2Y}5`noO|2dGtYUOUhyo5vEH&>6Nk?OPRZ5=r7Em?;AJRq2F z+p1-TvsXqC5#f*=l4qO{n8i43hiR87)tdM8p?{`0dgJ-10`Gjw8BUnL^yf4V4(W36 z7SLqi6FY(Xl|=0LU5ia#YZ&C);X9-A9d!Ml=!@=oCk%omu^`3v{n7Oj9KMT!zUTIx z%i|CSulp825!VD%H#SHTn$q5+n>5a9Ro>-eEk@Oi_7)n87Df;!pxVdWrQm zqDY{eetOeO5F}2ZfhOo$L^a~BJ6P4)>OjUFB20NQY72p2fB$S8b@bqtuOkza`ePb3 z7fK=n;akmY8e(EE_v}y5I~!*mt_zFx_b# zWHgpOS6X!hym(-=>txXXSuga*9wP!|Y!n@J%&N;JU8JnQMRm`_Vu_~vC~&Dj4c=TL zBzyZ;FHmr)g^VDgGzasjq986PSVV=&NXz47^0{ zE^433=AB4y%6G~(wpsNd75Sgxv&Str+giW)1v=B%W$vmRnF&#yEhwYH_=N4hP?ZJO zj^xO(&RqASW;`}n_+-4C4Di8$4!PC9gMr~uvX+(>=z4J7@SInhEraoEO98Qp6_6*g zS3{)U?M1;G(}WKkFx<>@y0E>^9V|>h;y~EEQ;c;b86$vluuAhN-^*R& z1jl4y{uyTAKe}sOG|R78+dCS*Wk;q3-%bFATfZw|1ntThUY9zNVIfSkdt{-a9j02iK8H#c&WB_8-cm#^9t6(q?IQkrPs}&sTes5*`R=7( ztQFyeW5w+aRMDJ{Tyb05IM-sbV>g=GisF5SyeT#RT&R3>U7YCk^EumnO(8f&@TG9a z!XFOUH$qQ52~_{Z$jMf8q+=z& zeqjU7fK}f_RvkS_;-85P4262lN&j^A&PR(EVUjkt#owpWeDqeX_i1<$dy*Kp9v~-Q zD}7EM2DZ1N5r^IvM7X}nO~s|-{Z=Rfd7M3Gw26*ay@F5j#mAVAF}1)#D`#F2z4d%2 z1IIl=KH(h&OP(7Ki>2~p5|VDGD+vx9nE-|zB2h9#y1P{S*k$$At6ovxIIZE(uvvP4 z##YpwF!u6Tkk9vj^A;Mit# z>P>Zq>QN;*s%A$d%OxDnHm`r5xDGE@ik0rL=eok5<~6gC_|u6K|7YCpC-yqo>Nb8S z{fWzZF44;|GtMSrANZ$qA6^=IN!^-TPBwnZqqaS|MIAO(@bqSHWZFdsGG5ZmT(Mh4 z-ek7korLxx2t1G8xk%a1Tp@ks+((~^KACmO^-3SNeY)LK4)~y(X}R+v=b?~(3z0ju zMK&;eBYgK(Ciu{iv!TU;FE35l5UiP&Au`#JH5%@uS;@VOWAPyr>F=auGCm;;;la zcX6ipkOuZbNn_ZiF8s+!n`d;48eIYTgzx$B)alcb z6knqkuu>|D;Agxn#%p#f!zNF@2;VgCX{I?HEnskY)*!MyayVorr!&IA^rdCt zC|GaJv=yW|LG{Q4AF3nVu2a2ap~OaBIB2kLgx(OZdHfLJaL@bt$s;3|;WE>Ar*X-D z{2w`Hq0db^+9AY%=Z8)aWxhPF&%nR}XRBYal7M|x`G_6&CBZH=WoPDRj$jR#_3xoV z-mGeO8f=G^CYqQaiK0e7l)Fgjb>0i5ulFpl5`%4}ptZ}@*m>$>)?#3s#bNH9d{?iz zuJ>EyGrQZOUxytFBam8rglDM0cr31T1_)Bv`WuY3($tJrc3@Hyl z;KlGzYRda3w%bXdaIY_ShuOP;6eBUu4NAe9m`$FKZHQbYa3Pnv3J4i;n4|=xrZ^(t zptR*lfv~GH^IJ4D2N(gao7fgH@RC5>ky9upJT$zST7i5!QGt zUu@^7cmP#$W;yH}tqXTLovVp7Oy*UuIV=$H`}9~ByS=yCwZdm`Op>uwd05g7R26Yo z%lmo~>19r*4`SK0~Y2%7)H*g3_B(nZ_4ZQC|?+qP}nw%xtkwr$(CZM%2d?$f!+ z%{>qQ!%ZsnP^&7bRavQI&H0Tn@~DNV}c6=k>i9Tr#N_}F(XV(XZDMfEQ#mgFbwZE5 zd)VviYrMcgfS@S=rnXK{B${A?{_SlYLHic~Ktcb#>saEK9H-u&TF=@N%aYZUhcH82`od%q%ePj+V(Y$5I{!D4oU4S09jc)S6NwG7*9_fgek;Vd@itV-Z@mL zK>v^*RKi23CV!qyV_N;$084~F{Oi+*eZ#0%%`q{}g|4eZUhTyv`a!Q&aypN&4==~R@*&di>An!^sb{C7q@tx<`}-?zf*m-Gu5Oyz@vwYLE#8~?<3 zuo`?CHG&QRcxPp01#SfbRP&h+tRYx||;THQW4gt7x$=S%{;2Uz>h z@?r4GL%R_GoLqoCKD@Oa`XPd$qxWGMg957q*$C)I`K{$n^Jn(nI{oMfenKN(prb^45L01=MwVZ~$s+Yx4jE znuYHDIi7C<`0|PIJEjV-Appqljrs7F`{8K#*u~O+_u@|j{Fy9<^H8Nj=zENvi{^M^ zug>Xh`{tYcnoaugqxuOt{!uymc@e(1jfwGlPydE`{khX(55VdEj&WD5!M^l>S|XTj z1o-aF2kYwXH6c`uGvv8xINYws((-=}7N3ed6i& z1ock;s!e%`KlYXN?}_{~w?@6ay@Que!7pakY4SVh#~VI?UoH=ILY#LL}b}CSLb!s*((OU5?`AwKhX_dhT_Q>-%(@SeYgVP;%btc_eMe0wouCFuF3e*fNEfYQfmpRJFP17W_oZ`eL+dH z;#N=^54X_{P{;S)%^ddk8>8wiU*wO2DCw9xjyPNLZrX1|g2`kv<$BaeP(SXcA*`|^ zWIBILP6J#av`wiie|U&BF7G+0H|y$Z(bo`>@vzuFj&E1`Z0LV+OX_{!4I+XP%Cjm= zjNyu56N^2l1%kx*v|R`_^y~iHq#46mUFXm3w~tB}G~UG#l~Xot22JUtif#lgn7JBV z6$vTgXyJlI^sQT5ftA2#3_UssXIn(aJW-IuAncjskpGm3n|>5}AUn1X9#=B2rVu14 zfAM*;n^W2l8;vpwN-C{O^;{-qy_-)f_B~vut1nTtHb^iT=Z$Y3{N(u-vqGAm;LK(r z^=ZCFca~^A&C|r{NW_YE!{Ep*?>VEl9G1Eqto{}}4CSJwJ=~{vm<*!F!ee?NE^~O8 zt+ojIxU2AHdMTU}Id!#Txhl(0N34MDB<(+cTwRd4_gA$JQCn1x{uu6U4QwzoS1xm; zgh;XNO)3JSNm7hnw$kAA#kDe_#jhhkig={FO(@($M2d63VwjJN?hPO#Na3gK?aWoPRFY~zRsn!pR4F8(!5?B>-d*m>3*e~h}^b)D1u|BCBj`J zf1b8E)gXChNAfCQRV@=7jRLpoM+aqG0`xsPw6emhVuR%Q$`A3&92B$_V!t8@$3G2L zZMP9B2t<@RC3=If`Tk@GGFiB-QN1hUm(mmP%NvMgCQD1jM^td}{#wTl3MwWC_?cuf zEEZIM^(8i5mYN=$?Kr(N@ZJzosN}aTqz&34U0O1pYETP9=K>PdzeMJqm3F>0EQf{j zta(`IaOd|LD9+1geUylQrWN1n0Nto#4b)|~*U^TgT%C5|LMx}ezmL`mGEXN4XqHWhKtaLAHD^J^SgJ5kc+I_+bk~jn1 zXvK&fOiV&q~8_zW25xr-rO{X>IDA{qtQyXX;-VBt(3~$K2fbOA11htNS22 zM*x0*^|yd-Ispe>0<-Z5iuK%&g2wVR8)%hN$^K6$HCE-`eGkuH!sbCByz=&aama~3H@tizb_{H!RD92)1g6fTXm^X;19l!?i{dVdsyUXdtobBt-1j;=BHmtzylJ6>K3U*dH ziwt1}S--<&85e{Rm`X1rpJju#+J7Y_;Q=~2_*(Ac<~E@uB9)ISGBnnMm@}o zjw*P*3w(O%hPxX7ZHdw{ z{#TJ3YnPr6ac7`=ZknuerWONETeu8hcI^SCO#cD;&voU;sg1{78Z}V#tH?&dR|Vv< zteC$G7dmsH$4$DE@&>Vjd=<6-3wD8Sh|C?Qn!00o$=tJVEyOm8lG7xMrYpCl!a=3ul^F65 zE*G;#bvdtB3i2~hU#%tJCF68D;qDD_OA4-n*3fh+B+s0&p@?xJ?rUzt_Y0%j)SBsQ zzr_;6Ba$*y*2*c2j&K%7sC_^;M3O#cQZ|kOgulVuA+#sVdX{X;WhCD|xNt6eZ@~lD zt2_D~?U%X!h4f|>S~_2=!B>Idt^*&>^a5w+4V$V-h=FiPm#bkh;K@8~JuyA6uXpOh z%{axY)VU%UO6hGZGQ#t0eQJx#Osg0%BR-5T&;kDj+Q+eP7BGGE-TO-dSurc>?Rp@QT-V%(V1*q_QL`mpk~*!KgS;gn>Eb= z0ebgUvi)8)65LKhEWY2(mK3;N;gq-f$@u+AL51sD7${>iVSZ45zUI`vAIDd&w9&HYvwd!scg^*XJX?|lvfLg2r z=77U@>$*HZ4z$fUPLr2q57F4gyhw|r&KVclXP}FS84jjTfuyUJ>s>i~fO3Kga_gEI zlb+rVS??8x3G2Lg!LAb%ziv|hH`8qGz)L%aB%;3as{ zDiA6sE1^9m8)dMl#+bmlUOxtBLgr~x(}3L`-|EUal|ZVSC`IKw6DYJ++u$mpX7g`U9xQ#aF-7m9sCqw)E7LX zBQ|-7v;{~Fr{9zk*S6P_lt*X?n`H6M4pUOOXQ86fI?WtWqoH(z3{Oics%l=*2%bK1 z_W>_UE9^XexzlzB=_lOHsO=uPGJWJ7RT61FfPvXbk}MNGM^|A7Ykj}sY$f0+UnBm~ zUQuZ~2kEG7@P$;jL5D(r>1FgcWUc6F0|rE2l@2Y>dNVPSIJ}NX@B->b8_w@j z$b;>X)S{(sV$oXRip2I@h}C{vs~er%=*FI#M{K60p#z1p?^!-h)3P@F;~kNSIiWYL zyAo}bxC9G{d`B_t-9?o{_~EFoa`4q`(_x?O?mdgm?iCW+b`hsfdcx!GZBXx0XwGXT zD|UaE&20I9flW@1njV6(%1D}V~;37adMDtlz@z>41JT+tLQtl$(Ku0q9Sss7FL zXt;+-3|4+|26_P4Ck#y#+042!QDJI{`lJaVLsz>BBGC-p1cj)SoDTb+#J1ZAp;n}1 zM!a{WRyF&`+8jKp!sI*e$SJIsu)GuJyE;6UyR}+OmR=d_`U?Pu%g==hF5OhmRvneR zRo0Xvf}FfE6*vK!Amubw<@ELQ4$h#%5n>Gm-Xe8O;kqzs21pvB{(P`a-|U@_K59Z{ z8qwa$l@PAQ`@2%fHM?x#n~nR`Wn{#;)#V~3`zCfh#Jth?lcuf84&b8fP|UjEpFoSM zJx)S7^;L)SQv6iV0^R7GkCn}rj%dVn=^S`@HUAEu#hNG4EtbOy)QK*;A(|S46K}1H zGd%f1FWy(9u(aUM6Hb?nK!DI^Bi^j?pZ6=`3xiEuc_}Fs{hza8!++(>eIA%}o5n== zY`g|Fhnn>-FFO7xU)MKex@%mz)StGHLhXCeRKKl(C0((U^Q!uQH6NR?+A_63w)*53 zN%uVL>yDh_#O92;a|&NSk4TVh+zT9(a$EFc!lH>{TGm@s5p6BoXF!eco0*k9_yXu4 zT~b4#E{gyMo}cG?=tf)PE8>yblTrw3M-$r!V2%i}3gE*PxiKk#?Pm~(I`joc_X|(7 zIm4L_XokSYxPm^)*E{#crx^O-QDwiB#qO_~>o4I9OU`!{pf{N!+U(Z|YAW5jrSE3v zv{qSSZgV?Q(y4z$AR2PO+hz1p0z`w54h_;Sx3?B%-yp*Zi{*?Ey@1E&?L!(!Qzxi% zLgQRw+)%W^KV(}sgb?EI+_v zT`u~RpTjJfpKiD5so~KD>p|szIb%`_bb%O0sc2yzD%Z)?ktYzn?(Fp)(4X9~#)v1F zn8GiM<@)eaQm5XiQlg6Ori8&QILLI3tSZExOdI;3!>)&lx~ikdlYMY&7N6y`CeQ?* zb}GSi=C<~W9IV!9ctKQBeVtXT2`#e_B<44-_)viCPS-AhYNBqb43#_;O74W7!-;Xyzh4d_N=Jnkl42EOjvzG?cHA+Izd+= zIb88GUZ!pIg-#jm)y+#t`V`U1yBvBqV*UmOJx>>1G>k|H>?Ef;rmGS$nWU0&6S3iB zm+k9k;ugYmj8sw;K{94N3RRS98dBbBC5_wf*Sx*}`4@7B8E>NR&F%P&Cs_)MFnNy(S>K*H>@LmsfluSua5{W{F!9(>p zn)@E5{3TeH5#coMT&8kw460f3ZpGH5rfrR^+UnoiFf|UB{j8Q0GUGQM*%i?pyP&>u z5hzbqfzp`NwhU{&(9a<~?Hk>f{Y;zPy?T#6iM47Hf=Gr22Rxu*f+9`3zd;{o^$|A4 z2#AqX4V4A(Zg~uW_|9rq4#nqil%+J&XDm{8wF#LnRVcUDmyw{@()Zh;bF1i=(t|;b zPqJJ(kl+VxVJ|oh>)^V;F34&Vps|*2Rw$2L!i=A&4Cy!L!fQuXB5iJUa*o+}QI&Oxq&qvYgxDT4gMkx_Q(}M_qHFkxsiGETba(wp zhw$#w@KewmNp;cys7ghsBwuMkET`!H=7Hf8vVE{eoCxzYfYnuH@&bx=ERGeST~Gd2 z!1E=rc$69RokNTo6b4eW*tB+o@7BPv!`?^2)vy)<^eSt|E$r0{V4qf7?Ti5Ijjt5+ z)mFbpwf#7?6RVE;^puh~zra*T<(eCw1bKry&Q4j9z_Ro(){=58|Hw|tyC220O*lLD z{z$8m2pXRuJ78l1wikIwA$v3Krv5}*K8ZArw!OJ{@wDGI8hnz8DYdB|bZZQHc+#YdyuzGp|SFcs6 zW_bIjf}C+}jEjNo+u++V@`AsQ^B81o|16yiQW4kPgIGHa&g38LEJ7nw{D&1!9c-f4 z?`8i<0y428>7}}n>K?HZiHrujd)nP2?&| zj@sD&I$;v`JgC4X^-E`q_%r_^m_6}_Qs(%u?7Mkie5UU-c3n+5SSyhVik0nSFR0u5 zhF6n1$HjB09NJ*dcZlzU^l5-~S-WJd1(R*in^(=tQQay{rfW%Zy+`G8k0 ztrppr*&NS27xil=fAO=j2yCP{5yzh5?n{8E4UV>T1~tWb%87@*zJ%uM4QP=qtL=D@Hk>sq}ih%Bq15;U}H@l=Pd3Drwnk zmrJE}(^Aw`GB6`CiPayLa6Fguy0)-3Wv?A3^YxMfCLk!bZCmP?o>6t(#HMVOYI~W7 z_9BWXMwj8r)PRJ0R_0iHCGLOETtmfOqsQ)1GBOd)8}!-iGf7i_=-#u}`HEVO!w_n0 zndMc&UDAwrR>l@@pWSy~Iz{En6t7~;Qi+yNqKC~jvkJ+%O2R}JD%`fV_+h*me_l<`~K6KD*idS9Rl}bLAhRY)9@a= ze_h}NLv(VB2zX@R;S^B^W}Mb}FGq1Q{otq2!z|BeLYf@}vP)zZJnB=_0SR~MB6Xx? zJ%}1E?U@*P+Pvg+Ml#Ei+M71&29^282^=bd6+2Pk*K_gfs{i!z*M}&RviEj6xV~*2 zACb2VboDO5F=-eh7=JfW$*$yrfO1=vI{n}_x;vTrDnm{CA4hhY%1et0x5l2ZFp!=a zzEF_66zD&z%`hz8E(dKBtIV-u2E3;F?uQ!qn)=_EKyqmK`%Zpp-UZ|LF z8wNQhd7Nb;ohAz<#uogj1)d)SIQJPbs~X8l^VYJp&m^=qY0%S3B<1<7Pw$OfS!8gM zIYa8kEXd<f z^}*2d(O-?@s`SYmuG~y-SX90Nm_=X1hmmp8hcqh`_OAxYj==C2LJv$M30Q&LXbSm~ z!h8aZx4rB#)obueZ4Z;l53gvGwuG&aB7reX**8kY5~+Q1x$l>^*g;a4g|gM8#<>vY=)WPuvrTS=uiv@ zn!E8~HVUH;aUcm-Uj=hE16@0K!&$O{CX&oQ_mmsejfs#v5Y#3RG2=K9UN%)7dU7Ez z-52pO@n#6U>mM5!be`LH&~H{CRVG3 zSs5s#dZE9}y@~PcT?e;tZ6-CRU}sYk`gv2j`zRjg-*&V3Nm3`$jg5vCJ6LnFVxiRS zqh6i5yne|1SW%#}YK~U|hK@6RxU>9+sCu}Nl&Snh5b(2xk{oe}`|J=Uj&P-rzGd=E zLkL1n<{*`}H%tWVpt@pbux^T$^CMZjcimN@B#9nkQqf%6N$+7B9-~c; zAHj$^Or^U94(xwEk3&4$zN-_jw~7}vaCeIwz{#tfs2eE+=KM(!q)6S6Awj!>4I*A? zdHNi8h|+Fby&+Kd2(%r$ea0qkyB&t;lGp=A_!VhV(*n*^ZZQ{Z_Ro~NwM>c?iYxS8 zt#v+LQN3HR*dMO|B9eC^l~CIcQkY^LzRqaW)xX=k4yg+1uH@6asSiQVov-H^3fzmO zb1lBO!q`<#`s}%0jg-y9Lsl7LVKmB2JQ^$*ZIMwVA3vg#sih4kO!)Dz@jHi4s;C!G zl?|&k$s7P-K$d1&K!DYx0w`*Cka;H$#$K5u_!MQsZCqPIR`3+yxTQH4wRj%Dyz}On z{o`<#kfgQO)i%W94}`}pgPDA6GGe(-k~l;gP>YG2ao-^L9Ud|X>4MBRMrh3?aBW6Y z)=OgJ$1=d|pxEk4`N6MTVvsVu(Kf0OH}N?d_~fmuz*jzl&P!nYzL88#`_dfM2!rNY z4_U9*ko(vR-W0Y|u0-laB>Jj%dpIrehYW?cI@swUZ5aG7-yi@r+F}Yr_DebXC^pP` zp1Z;b4J4s;@PwCt6 zhf_ktpQ8q1%Y(SDm$*eGHT5H}T>ogfN;vcQqzh|=4G^QXO(ybo1mx()f{?}ZRJyij zw*sD9>hO%uEG&?^Q4g%&t<$8v6FMy9-ok=ex+oF2H8zRI>}3fNrAT^lnQzKaVnFL{ z?*&8#6?KTK-v%wzN=16XG6QW|A9lxOC1IVT7`{n0q8()l6kgHW9_kQrbZM=$wLKsIr7t|Z?hx{pE2t!=l@+Y&rH zJN>2|_*Z3^F!3RnHb6j;;Yyze86|aNZ0b)<-!Qzk!8e}e&uXt)smMtqLDA;u(5z$b zZSWSXnBJ*|pq~J+m))lA#zZ5y`&>`~J9g2s|Qg=gAf|M;Ncpz?)*p8q0(^4+gCRHGCj5CV(=1UCE_~}irkZK`rzYq z!Q80h!SMa&c$1tGE|>CYq{YX4w|T*+m#CI4hgJ9!E2txbj|o8!9V8n-NWuodd;RX8 zIFb&0lF)?Omkn_g=5ZA+lKOZu7%dQKgBk=k(b}4IHvXxGtX-U#88(Q>l&6G_=!l0g zD5$k#?8Umq>}11Ec=$?1vC@rCxl`|*Y)lWEy6=JFi|#gB*45GxbrR7^gpt?VXRVNd zH1iOFjX<75hg(&;9=-^a*>HbIbZ%!?dv~V^R#x7bj3L(z_6QjwuZ+$h`XiJpUT;0@|)B;WCs`c4GmH)b76}^3$*;YXatm%@oHEr+4X}@JWlEASP!*I0lUh%cR4eRe5w!cjvU)dpz04>Zm62wP zGssQqM4UH}8n7S`%ABDPDS2n53D9G&A{^~OsVU?qz9YXqaj>r(0Zc$?G}Dx{YH738 zkZwA`6kp?1Qzbi_a$fK01UyV+9;V$!jK8HA5~&qg1J{NHy|qXctgSxT?KFhdT>T28 zL`i#Bu1i7)o#3wMN5;HiGn(DrU&p1?2^Atf)*`!~Cpk&k&#wFw8)o-x=tpBVbdIom zO+8OXtj>xH7LDPiiea9!Zj^osIUEm^OHd@IH_x!Ggeil%(nJa5QSQARY(s?Ngu;IWM9 z{?G*3#OY%FQn?7j!KJk#h_y9_B(;QZbdsFW&3>PrRAt}->8W2&lb<@#@$#9<+5zfY z53iKYR3maGPZm~X%pY%erK4qU$$Ffk8O=vR6D%c0GTJPablv0nlT2;BNaO%YdOX%H zQf(sD%FhyKWA_cfCWjpint|}pHr4oDNTxa{s_U~g7>k65bhOcfarII7Id_E#3l+jo z5-w})@~aCpGUgu|vrzw}cFIY! zB8zR*f+-z1xMi3poE}zNgO`*ITB{MU#-nd)!mHllBgz1Iy4CjK@UKQ~G+PdL2r#bs zJ1B%z=-E(u%TP#>+axiDoK1Mp`YCvH-E8GhtPv6tYqd^|Thpf+Q50-Xpcs&Hvo?(q zZ|`3{7gVFMoSJBGO{=DaliosSC(Fhp%>-z(Ak!PTmwNEu6k;6u zdY3;3f+&^+7T_RyVlLmC^2TV3Ck?48vOcE$QOTlB%+idkZ+X%&1isX}Fm!3h2(8b# zlu~b*1>-91wX>d(7qxz>)vtlxFcOF=bQkhPcngf-s`YV!)6)V;bB@+UCR1BUVB@eV z@V=)wY5xh za-PV3F?QMSe?2X!NX93{eTHw($|1?gBQMCBda^>zWgV{?YexXkKCjORc#^I3DHa&d zR4TifK0Z}5dU2j4%Muk-ZP@MxrKMth)?jpLVGQ~qOQIUicu#VizbPA+o zg&v4TZ3}JrD3e z;miNrqRNGPI8o{wdbh7(v#38bhv+(5had{o4=c=w9u#R5Pb+;Phu) zB1{Jqe1{1Bj@hf$_w~F(RIGXNTuA_xhIkEA^d>Q+OD!;DC3I-%nub|zva28r@9ylY z@e%vZx^l0mocI=!ubVA}JsX~-8OEaTMu5HP+~*U1TFHPGKG!=v*jD2GCdv)E_o|~Q zaD@k}4UeFw_nF+|xqaeS39GWHr~~}W=yXeE{12>2IH*N%J6hqZHm6{L36D1QHcN zfTb=CF;qj*7DEIQlaM*Q**SyFN@0sDdTJVSck@r<{lh4=#>vF>Bg+E7Y%X9=J#*~8 zLOYm=YSeM18QfTwcna`g8KSAnnS$GBkyYrA96!t^v#cbpB5(JPbQH~)#{m%SWw3iC zzAu_hq-T~jjCDy9HyhwG;n_sJqdTgSpRbWTxG|Gvd@g?$2fOLsXSBep$SF;1P=wOEFN-;W`J1Mr1iU~d@Ob5^GA zMmwF_LV|z**N!WDcMD>Pq5Ke-1;^S6x2@rYNWM0KBV!DTJ5h~&-e0KM2fsrfl6iX~%3}h)*Bp+&L1#<^>tcB%uuBM=@#Ta6Vgxa+4X`8`m>4#(ws+US{+pt$bN&5!qlQCiW}4^(y&RL)w~3JzA5Ub6_3OzhyOcfg86l=_g8(1kckPfX>Qz3sCdH$a?H<-i$E8wX`el2MtK43| zo}ZC!#P=1p--soNGv3E287h5M$p#>xl+%VDcuZ817w;8G?mD;w-qiD2J=!PMdhu>i ze++q@1S^I301sT*uNqOii^8XqPjr@4tvEU*iegB_Q=WPn%{xKiSqtz{grd1uqDYc<<{ zLc3^K#K~-o{0_yoaWg;r-YTVbOG2AYmUPIH+KJgQ3HK8V2TAIn`I)2F zZMj0{l2S}7<#%A0C|u%Wr)@_Vx1NfpQ%UXt8)y-kBfvFAAJ43ufLQ9Y=emw}M$Bnf zQ_Casx)mGLSi&_}D{ynI6k>QE-iu89JOD;m71txbT?{Q^JQ!2JYZA@^qD1pFU9p*w zxG$?DIG{taO?K9+Rvx7~e#!`v)-*Cl>@n8tlqx7Ep#2$Qd0a+%Z(a9#`soLPvi}ymEZnbR~{A?aI1fT(>r_w4J!*@<|#M@GMn|&&rH3W09aM zAj;tbYPUSKH;Vdrm5z3SzW&|D>{VxKKnnKWt~@xdeZA*~w8BG(rL>@(by6NzF4!tt zP*1FMja}D2_ZPS|e)I>p9G5@%ztj#K|DkqZ{KNdeqRAMT8Q9qVulV7An<+A|Ff;u5 z|5ZCY11pnSzx2VLW-zZSm6C0?T#?CK8*jGQ{2sDdQQ?VKJJ%omTeCkOE1tW{nl8SZ zA05v zdD-3N&8Vk*G{Kkto^be#20UT#LYP+6{zZkL{sEAEeG}t-BNB4(`bDLuud(^fxa9om zv*Sw$1VYepO)Wqhg9#8Cn{6BESefkJM{l!Y0PTRk&jkfVzuUR_`;*SiEb-4m5fq;4 z12uh)ndg}S$~Un70p)D_mV30; z0>T3Nw!|c;G=uzfvudg%0Wd*U`tYMns*1+Rdb;%YhYtuT2b`Pu9vq&ZKrjb?9fOlk zhyxp22dMrwq4}Z*w(RSL2k+ybyxq0`dH$x3D_`E7@dN`~Nn!O=ttn9*0U%a_Cg7J< z&RFRm4#3JYGkHzT&k5;%3hT{D%qb7a`3~#fE&c~642lBaiI4l;$>#;krGyRcrRk*< z+3Q*KK|M9f5UGv{rJRE=|K@KYhTwghK>>u_D;{L`cDL~Uh8{qhqRU!I&luV;h7 zxiMF+p1#2eL>l~K^FSE*Ma%@o37~#aYcstAfccznBo>hWXLZ((&%#GKEx$QA~Un?T;EIh4~eb zeW?N1+#f~;K=rgWfGV6SfZ3mDqFS@}8>;VpN&^#P*u7V^di>JI+`#N_9>Aj?U3jRz zpOJ*-?=&p}|IgVpzf!Y&w%6C;+aHg$AJ?}ZwnIOWH$U8mAFcSZ!jR!z&wD@2&!4j= z8W~#cADcUd))+W^E&`*kdPvouRb|xI+TmnCtPD=gZ@uc^pq)`V2z5-Y&ldujD-jtT z|IqsqI50B5*^%BMD!;4rkaAS{osFHx+Eh^fL4LU(KWF?&6aDWy&o#fOqg|@K(d$n; zQABEBtHIussQ3`nJTtS>Qz)q)28k#d8UVM@SQ}=Lj!&K;08UM6t1x)G6Yf7wrX z2Ea3t?>RBoa=yoSop*R2?Qjqm#Jf2!v&KLPlqz@Om0Nmh^W zpJl7B_^*gFM{>8Zhl~!*3~%mGV zlSJeMpc^WZWmpDQN=&CF~4d5{0Y-*BZNXX4I~H{L)xgL+nI z+UP#9tpA0R0f)FX&h8v4=%?sPYX94@WA!m)I&HWqSmIEob3FMA0j(34_KpeJOi&#j zZOr`Kf|mUDQED0E>Julo>qW^d_FMl`QMIt4f7wlwb0TL}Tr1Am&dR>S(xF8vi6l{f zRLFpwf-#h1nWOGQP#P>dTyKCz6Pqlu1y_;=`%<-3<0KwmSxkx(Z#U}D& zDXH*!pI-DH`{05x)Foz8pY1H>&_Jb^enz8}&JxMCHA&Sfv@P4KBVcp?gNFjFX51j} z6Gt_V~U`)0rY4M%u@uDoDIgN*G|c!HoYJpqFR)1NwDUuikd%WE{OT)yC0JvWYF zTg>6no09V~JC7Q|-D>h1*z5jv$JcDx<5?_iKJ{ct(;3qqr7X4tx(fGEkpN{iGJ_jX zlvu!g-Arqb=&;ueKH;%I@psN$CHE> zZymKFJ{_cGs=j4W8(&fLrXN}h-+9P(s?((z0k>C`o9Z`iEq*%m30@iANcFni&^9?j=4SdDEOr9+Yg8&}_KMilc z^;jDt?pTx!M9joS)S1GSk2JMVV9;38ZtTeuw{P$|H@-C3<@YD2f{jQINygOBRAmp5 zRuq8w70kdX#2-m8qtg%IksNK)j)JU9v=ZCz`|KMQYuids+tEfCcQKUw=_ajm^wpky zB0Ap-W1C;ba+HR!0Bna_)l?^nD;ruq63je|VFunUnciRUBd^`#)0HxQb1#VOvVzO-xu;k$d>3`=BP-oDqbCy{hS8H_M+qJ1`^ zB>4HCO=)G!D=(k4Q+<^g%9s|^RIL25w-%O@7XD2P`Z z`V~*j-{lT9Wode3DwM#v8dHzsS5IR54w+##n%B%%eVep{G`^ac#x(6@>s%~uj3XI) z`6?K^%n>?UK@K(w2SB0iCGZ0$e}ZNYGWT&n%7ho?b_j)zLz54=r|MG0Z71C$4I3Tr zII#Pn2@Xbz$)!?ydqv~iV%HOdG55xJCgGMNlX4CdxL+rwv>^;s#5avzGrPNaZ5nf< zGLeM0D!d)fNW-~}jG{-OoytQ~Jsz#s^Wkk6~N)Ts|b=}Sx{3GggBrVt+3f{R|0 z8g6E>Vy~8h;A`P)NJY#P;nYWvSss5JDa*J-)w3aI#R%fsO_ASeFI$KmndGdCgn{xI z({rAhZAz(c06fX4*6+uFLZ^SXeRt5hB)sC%^3(O4#QE5NBvw@|caQk5p^`LJACmY! z*k2V$1F5gd)ZRVJcM;;UW6(A|m7^c?n;}iOYOS8u+Y)3<54sc63~FSTKAGWD#v$Jq zIk^F5VS1%+(|33S7{6AHILKL(z$aD0pdch6UExy?AI(z3Y|E}Q=2_BD0+})d?-JB} zO>4Nvgo!UMJIP7k`ElxjM|ZiPCA zeLRSmQ?5OLGU7OwCzMvj`r(oHDXS2@zINuHUn6^Vd8l0|sLEjBmGuqt^DE79itnYb zjnH+6>?th-ov!7)H7&m@Kj49k6~I?|V;N%+VTA7(esJ#%5}wW#jUOR;^c#x7`)*q@ zHGMvJO~G}imt_Q+QPc3Ots@@yxK?O|q461>W%>WBNAV{hd%G50&2pfST`3m8L3l?d zanUfX@aJjJr>6202eu$0focK>&9qtU*4!`!ZvXkl28E=Wc+P)Y!%Fn)lc;EL>5q&{ zCTFs19O>K^kM`=sHLZ;p;R+Mics}S-Uv4p?VH$(8K2fO23_4qwd$l_!QwJYJ|!q%;p9{<>Shi{jA3+$ZYdv0 z9P79Mr=5$h{+E&1GwJPN$Sq&5BfF=D-$e;Al2(w*EjLzi(4me89k`no(NcZtpy)1-u$wy(vKYc@$5gvk!_UPr1D} zjS(W#vv|k&di@|!kc(MyxMa0o=+}~$2t@|Fnzs#gj3JXU@$d0YR(Vca!XyFeAJ^RT z5ck%tplG^tf*#LY@;dh^bXo6m`FZ7>C!LFRtS zPZ0?bNBQ5yVKSj)IuJFcq2_|1!X7flGjSeS1 z&A1h`zi0WFXPXU^IaD=tHk~uuQ?Zo^W9n7HWnBecJESw!%s-bA>e(ky{)pGSs9e)f zIFRo`efo|%TYQ=-8XtOxbgxrfe<$I&@p^qh5ef^%K4=zY|5Lkag!Dg*okMUYK(~ft z+xcQoY}@9x}n%`dj?{Ij{Y>Q?=WyX<8zy6beG^FEJKvhJn8op#2L z+~U~uTAZkYEr(x>5x?xvb{1j9$b3&TZ+kqt-h$T_ev&cDUJ%+;8!u?#ogV``)`xbD zYQtL#5pYB~s`X$N%L-=zRm#2gLa@J*SU zS)O-?5xC-$;Frf7G6k875LO)52}qJ0cN9x0Z=`}2edmjDB~jAi3@LkR-m?(IVy>6I zKI}=OBi_ki{+Re<#7ziixmuUj(~YO~40F8QoL40zszt-diiLSWtBD%DPZ>|%bGP)< z?2ji5&kvtpZ|1&F`}GvDe3O5mXs;5zj<q6@ZmB*f{UERe`cA;u8CoJ;|Su?C2iin>n{3Yai&-TLU()v{aUHFO?4qT^3 zCw^fpA2ifcf&CFQ3rqtMGHe-j27HCH(UBh8OV*~de5~nqE3;aNBX+jCm|l7K6Gi&; z>{I*I%^sDH8z^alC4G|6S!TkU{u9@)?udRT8CTZj^u7Zhc-x)(J-3Y4p(~p=!>r_r zEauTenW6k&BWLym+`p#OIW8Woc%E_WU^q1ZqFvH-*bro!o71qtR2Up%Q)|N$5rL&0 zdGAoAlk<9ww)nc79v92Nx7aWjsH3|#CVkN!;)#ZbjuyX9WbtJC_AWG+)KE~E@h|$_ zD6=7##jqED3MyCbh+tw!D&C$FQfj4(?#IeOMwa{>wJX+tWbSkgs0!9rx#-{}H%=Yu zpb70W)x=g#mfw&mQG@D4ED;8Fl^%*2e3Eb2AHSe#-bG_WNjB~8(WmZp@fd`faJ zZu73NP7s8`pNW(W02~65^Nd+j&S!u`@C|B+$n(+N19keWBjiEu1LfpNyLo{F zicb96>&*KJsV_*GEJJ8kjSXL!M?Su*`;1n;pI#68XVxa%v@GrqbLokV<1`|2_=&H? zEOm?yK?pd3J6i=Y%nmFUHvF+9fy1EsW4glx8)V8?DLwzBgH}xT8>)q#HAv3kSz5+lt+E#{7<;Lhj_bINj8CT)JSnis56bScl_cS1)BX z>^utYzyo#WyI?~hlbC`eq{h#2xew0RQx&~+7aLOx#fT$SoY%UTu<2P0--)@N^*-+^ zSs_`gH-4mWC6B2s_>vsjaYYoNiR^4=U^Pw1)iCxDvF+zFqEki^{I6spnWl`$o}cdJ z9}4vdoWB%VNZT9J$+E!>Mxdqh6Kq31{og44<`N2)m7*IOZ-3+zP{Fs1R3Aqhuk`=H z=jx7fLg7#;vF6xGD2UHv7Iy;}A5l!o5mv z9sft>q4(n}NF}*auEYRp{KVTtc=6_)N8Hl$y=D3;E%dxDC@c3narp->+p{CMGC5-~ zJm@)~5&DIRy3cI;4W{Y1ydggdaRyFSQD+;I0tVUwrgr|TFsHgEodt6bJ4sIf(L6Ly zz#&I(QQ+IXP`yO-FrhDDLW-mz@}x)W&aua4r&l!@T}OY9Qn8XrKdYv>q}@VF+R>22 zC#nO#Hr|>8pc@5sw0T;=s)-O6CfWOIShZroZfyo!!K3}O*3s+dwWVuQGPI90<*hUp zX}w>B1IE&F%>_#;m^$GR?on)=T=knx*~blk2#xlbzUDz}*sByr-hyi)Q099=vq zHoqm&rgvziyV@wP5bvB#m@j*R!oBOQv0ur4*b!Cc#(LRKZqq+fJqqpKdKN{bK^U_M z6q|E=9HchOD;_L!wcHvkN030vG2)u?s*VQICBLw?xU$k*H=}|R1A>+AcLY=fRtR;z|e{D&QJN%ZlHR}AYeG{U4vKBSn zpItjhno9TTE2dTDLnxpNuZC7*k!T2OZD^C2u+&;K zE1!u^hM}C%m$G1|W&Fs0)9o)f>_o&Y@Z4Z@4(|!|W?sIBAyYjy@tcrufg~~L)EP}~ z#=t$8-Ia4FZKo}$$e93KVPoJ5=jxYXhyHOZKX2oh?swXrG&kLd1-hZnrzo_e4$r&@ zE<tjx74d>wNLvkpou~(> z^LtB4Qd$zgQ3N8dFuzz#y&ikn*^6Y6LhS*tPD2rKO-*3|+nh0B5WiSa!VL%OaepM? zTa;9y&Fusk*nlpC{8i4Dhf28&9xYI%NIkJBs!|UZX31NKI*Y4(yW5%aPgSsjhVte4 z%W^~qSO#A{x9q)%4uo5C$VTmp#I}_*TA$*BNBGeKF zs1g0ahX5glw9lZrORlQdb|9poBH7>#4=nNAe!7E6CCE##NqMsN#%arTF3{0F>M?%# zAlB>UEtHagVhbEZJ2#fk&%77N zC`K=%MFV?~h3c&{8EEk0LnW=xY^~YOaxx%y)ed_p8ZcDT6UG{O1JYngg38c#U84dK z@yOsn95QKn86UUfR%o63ce2zY;^%AILVN3T0bmmPx%ug6ryCBL>vt;1JC>TUey5Dm z7VFp1Ak%UQ*vkN9dL2RRLJttnNJR{yY+w@}aG55LxVmYq&x4#BadJE(>LUin$ZQ|L zof#Tx+^zX)C)|C{0>2obUYxJMraG4rS zy;cgg%5z7j5NAZ`D7>4gBTV=U9A0q@NHdRs$sX0NZ<^yH1rMGM1Dmy>3`d(Jh z-*b6l17e(&8ktvdQA^h!{BjKEnqw=+3l48@WciTYmXjR4mBV=)75t@v+G&+TJ^;m5 zCBckWl9+t9?$eYEdNdKWxhn*+T469F>TE#BV{buq!{veT*s$S_V~vWErU&dSPtiS> zoQD?2V`7+r+4VWh%~;OAQCk$D=L+Ss$w;(#A=TV7J+rch*qnJCc*0w$O6=gF!s_6U zMDuK(A-2yLFh%HD>3!KlA6;#L6opd5yb3S?TP*u7A%IYEn%i~%Vc`Ly1eHkemO*6F zn*D%KN|Q^iV;uP5%N&!jFa-VVB4qE9?e;ayZUbhlG@7XDR{~W(7@Gw>w{y+`j?W4hz{f*w0=n#uH@xig4hweG_^!)UmEMhMz)z*!#(`6o&F zwVwGLIq!zKb`dkuY-xUx33A8gAv0ddD)rwCP6GH1lxiBl?TN5~Ndmp$IO{rJU`v?A z;sWTrx}@WaRCB|E=7H(xN)MyqsWhKb&%GW^&Ql&0i&-_(=zM+tD{qHN0%4T`eK3m2 zd?Trhk!f0E5__|m?_SRtnKlt}&eXuyL$YI(V#N#;O#rm3Q#&q`=?gH<{Ys*`|9 zy|M=COQ!7-#p&!7Akj~onyVc~9r`mo7W24>2AWZc>@p+~EF+RSNE@vL3tidQTG51% z^ARU^Gz$%vzUdWW4OG59WO~-UXjHxVXepVKaGkmfnQm24P{X_sJogd@>@U6?7`;s; z30qTe`j6eX(kP6{J4=E<@Or8aCbO}31v>lFy=<2laSpLKqC)avTs>q$Y1?-slMO33 z5qZo2alrSGMOq#a6 zjYr>Gb-Ks7u8JKtQ|(g~p7(56jm*^HfEVbnHkMNk%M~<9KO+QLX^K;QX4YrMfY`ZZ zeiTaFyJnl;jQe+;!Znr&7l-ZH_NN_*GU->LU!>TybMxQCFJ>JHaNYe+rpjFe(@-Z%APF;e zAv(_x8_}^tLT42=q}sb>$mN#uwg98GOA=bp;<`^rDF$9hU4!3CmyyKxz0z^&`1IZ$7j?i&r>d@8;hkh}d7M zH66kfV=V2WUGsNL)47l;5PfML&AFWoxZ0PDa=@6oRqEKB#PJiYqhgSmS*<^Vs+ZRP zIRJ`vt}A1WhtoP)yA!*`6X#RTc4fPf%M`VB6%7dXq_lhJT(AW-rix!S_?35e-9HXG zDw)^{;E!S$9mA0ISLF5}lR}pO_*v^I-L%vwF@CkFbp+&XaW{Evjeq}E2;6iHaSeP_ zi-Id&_y~FqNtfh)QPP*Miu0nH;7LFI*vq>5jd!24YvC1BELwkqyAAnNsgPP<)c|H# zgxA4ss9W4so4Uw58u7VFx17}J1sO;@2}kbRp+3{pT{g3MF~D3`%bdJCeQhsE1&I@1_2MPbc)KUi!qGa$ry=aAc*8)~)YupM!zu$|a|Dd2ew&le#b+GmGqH zL1@xZPf~3nsBe=<&(nN)9Yxy6`x|HJMTXZB!p3Lh(|g(CC2t!)Gx>jBj@ zGm4(~qvJ6?y0sUJ7SXqd!;_;h5K+Rhz|7`}vpmT^6rCKI;I6ga?e`yUzx<3eaUI^` zl!B^U|`LcH}Lh%{cy(!1#SVBQDK!(DY$#lgIP= zGyLh*M@$WF*_QO5!~J-kDtxmunr7UnVaY9K@cCh_Crns`F88ctV%Gz2s^$$M9-f(9 zXh2l$->e~-Y$8Oa))BN$xujQh6`R7IcDc8^6DFu%R zGc7HS&-tT3&||!xWL35bdM5Upk|zfK*3bU2FnXG5F{5xo~J zSL^!p=BgFYs$L>_e5haUk2foq17KZ}IoiHvdATKbaSn~;X`Us`l4!SiBYpN8Db=Wj z@%cu8<)?O8t9BKSU7x`;F@eFpdyxKE!_gNHeb7FUyzq0I$$Y>+m&SMYb|9?gedEfD1$KQc;CZi^=_9IO5eE6`=E@9~(5XhOzY<{b@dg?ALc;BbHmiDs`1B);57Fg=l`_S| zJH4ySitl+KZn7#rqhypBU;JA7tX(LvSVxono z&*8Z~&+5PebJKa4YwWSCr7&WQT6_0m+wH_zHWaL2-?p)5SS78VG}2#0G)-%T-4GslwrGR1;3JAG2V^Xnoj6U?n{E);@7!J`n+gjJqQ%R+4D6k*5;bHcVx`IW

^wi_tRJ9+T zdkkxhe<0d1{KYo{6vpUQ|ZV4!E{8& z$vmMSJC7Lm;TDkaHr0TF7Gnk6L#G*LOEu(y-wT41Z7^wC80V6k6*y|JHxbfThi2NK z&|`ew?i>LSUNeb#i9_TRP`^W3p^jucK@AY5ajpV?dGIOY>? zAw&x`c?Oto9L*&JFM+K`MzWQ=_r(qre}U)|CG6hLOoQOroP&d?^ZpDL)@-syBT}sg)>eCpC8A&2va{PL8_GSfWYmoL|_k< z!r^n=%dUA2i1un~2RJCWd8S^CclFc06sAN_Uodk*a+CNG7;&JN-Dh+>HAN?y9)3{1 z)Y2ea0G7DLmZm~>G6Sz4Y-ppBSYYQ2!XMpgX7 zXQsLM%eV?cBtblF2 z3gRvzo+#m8`Y;O=;*38w6S`QzJg~p_B2PH3r`Y$8Bvk+M`GHKGh|3&InEHM^q`~wj%?Rer znVcFM4=fZ82HeD22V-}X8MJt%lm^;yvH=iu!0q)Ps^QGYRrA22Kb|YvSI1+eAxzf? zr>{i3MFJh2XXen2t%HmXghq2-I&{34oAjb|P*w#jrxpP+K;JD>@thZ`AcxDfw!!gK zJjJceVs*av0#Y$w=#>Zouh~+ zp`lrmRDDO}MfM<<=QMn+D}!6G|_S9bPS&BJY|;; za(XLzTp=_S6}!}0c`v8s2=N%q{d8!sJz4D#(I@hX;Kr%M90|*eSl@tOj3?grPyTQn z2(aL$Vw)l2NKv7trWHg9!aWn?76Va-wXn+NInZuzY_7soxK*7qP{{6e+gz4Zd)j$j z;dfo@QJCWf3rC!Q+*2bp1gnt<`CiJmoYEU}t$`x3ueG zqyy#S$!fjJo8M|mb3D6__o5{OP4KR|NV=xdu8)KB+vT#(xlqTBQ3mb;6qH|%qtn#d zx80cp_6=EI*#Yyv-x~mek6V&C6%S6<#RJ~{P0wZLC9VZx4V#^rQHC`ye1gSJnU7n6 zaQ^!kB3-gcX4N*`f7^JNpA*Pb7`NElCj#ZYwJElLmA8PU8(Po5Ioh3IHO@}BsEIY4 ztv3j@vm{VpF*Z2O;r8whK&S|9ccv|T=B}V6-{nVmESR=l!yug zU!Vr}uQNUEJHQ4r$&pd9PLCc(O+L*JiYHYXWe)sBW{_SYA433&$0i!48BFD zr_l7uM-rm;O80=bwj9gVFaXtHn?pAhAOI(`hgV&BVX z;spHrrH};8B?Qz#b9DZ3J7>P&UaKjdv^Ao1c%^ts2S#$2RR~HY zRZ&SgV2S};O5O)@!=IG(ko)rp6ED@x#C_2gTQ;Rt|6yZBw^nZ#F+Qd<9 z(|-`HOt@{TH?NTKeCw%CJE7nE|wGW8CQ#!R@w zUAT6D!N|}H-)kl&;NOcU0_QQ8(v?1mQW)&C2;qc}@AX?##igl<&-~@6pqX#w5-%L-`S{gWn4xiEWVIs)sW$~T9Nv0u;0*N86n4Z?HO}hWUJ+~* zst5gEDE9bG&(Ml2m;Nvmw7#lCc8_phM#WPOC5sEL$Z-w-(5K=fQ1Qo&Si<|y&NBG8u_0Ozwe2o!n@WbPg*=@)Yv#alkAMjlRkn|p(`IK#Wwvy&afs!P-I5#$~Z9z z1d@6Dw}%)e1gu~qKUU#YV*$D+$qTTNLxJH)O|m^fADz){HYBD~`bOmsGNN}FL9`85 zQM98ySjTGu%+c*1JD5hC0vm*o3&<;he{9tA5q2ejzEJ29SVak^QfF(bAa<2aCoBli zX?01_5*DYP@{^0stpuyOswAYS2W3G3mf^)@_d$@otC5Qtsfec#9S~>bxRl>L&B>8$+~z++}G&RP8c}d&jD)pSmQjOb$U{ zpJ|MbE46)q3)!a^1OFY!#8Ai8RtT?zAlFpThDDMuAs$PUI~;;I{!z>Qpa_;;#!j%% zV?6%SZ4H|Aa0AnIt-Yx*&IGaB)}534CZRxH`qtOs1=)@MIJ>eBGo<8aIpH^uvyjq( zPP_>$PT{VnO%T)5*mTp*mZ%i7p+9XSXAMahfGiCsrC!o^i$+YpBa^EgBJE`Adr2@= z0vaU`bjw0)GxR}y-7U!Whz9xJ#{KlH(?>^pI za$()8u}Z0DzVGRntHOQ3>afMr;?*lvaaDZ-^sWugMRe%VJZ^*G#as`A8)tDwij2P~ z!nd@{7shWrD>!HYAuXqV>r2TbX&PBd&dUT!+$k^dvPz4vZ4Bp>m=FesIloV;m*&yO z62qiqGk@F^yVZm!k(*AVgN4Z}iy>8suk^sLd0Tm}z%rVZPcii{CLGY+h|mxpN~1{m z3)-}lR|2cj>)%u079|rL*zm~8yDd{4lEe8cgpn@mJ43w;VJHGL-&2H)hCXS~4c9M@ zZ5X>nel?gcEta;F3k7LJSEyH*V{E8W)I<%j^E|KVw1cI6uJDB{u9Sh!O>91ZXqo)s zrk?@E!~$C<^2qFaBod5&2)g`D+lVL+W4QXRD_(*LGX`!iPUWZJEaU0|vylFN63(}d z3dZkn#s4UIJ&Ps7)*_RwKf|!MUsS~{+*SW$+b?;Gg1XBpMDW~^ub%X8`a!S!7&ZWd z2=z|tx^I%b{AQZ|Dt$G~IRg)PcfLx$?U35`?P5Cc> z*Yas>hlP}`T^~wNrW@ACSPB+{48y(qURSl@-EsH$ubPSU9{lXu(?o)3w*9EI$;&X8 zD-Dcpf<1|8+7?j$bL%aEcBsOE(HpSg&0s|N! z|5Qo{ApMrHQki+I13!*8S;~P$*l?)Xu12u2S-ID}z`>yNcL9r5#b82=v|ekbV8_XL zo!vKete@UZjen-7xJw;h3&z?`_8gXwE5nmiIJ31$xMI+hd?_j0)Q@-hdZYPz>5`MssLB^+`UXQG zp{#k$L(=|Xr^xo~l{mRN^7nMZ{(yX7pByetYeeCAli!mD+{vS@75?gUo?;JY-sxY7 zPBid6n4S2=M#T@P-AIAc84ouZ4W+M_Irq8P$~Lf=t%0RuiwlW#8j2M|g$b3&^)9!1 zI(xYaRX@jjW|MN@y>Pdj^)M3x<>pQk#xXYKc-O>7d%3-;;KYj)eBdTDQtC~##yRoRH`OBWq1~Z zqu4G|Z@8`E5F z!;r4LN2NmYsQlg(HkOXW{i$Og$%+x_vq$G0dU55ehS!RL%tPXh{ynV{lrbuwD27@! zJ$~zx!z5QxL*z9v>6V!>zP(4>n!^K~bhW^;4OH;0^k5jO9GN*xP5 zcgGlisyTF&>6Y-lfU2s>=jPOcLkF>lrBICwBFRz?+aLzHVHJiF61=L_t8)8gGUbr2492-cyrZ-T0eZT8 z1@9|W#KGELn-~-tNXP3u==pzRRDU5ea!nd|`{NRnCjOYHGH^LjV1GK=h^tpgB$-mQ zwu)#b6FMi($In->*^4;AX^3JS(-!rJK2*AO1zO( zHNd`6dqQyT0K5Vq!T0;=X0sR0&u*2!0yGk<)<8&p`nq`KxYPPw0MY`ZcEV`0+I<9R zht$Lq<0h3FiZ46PjU2B~@4JZ)FMtt-bMjDcbS+&N&F=6Np zI?XFAH*&@<0V1iUGU})vQT%eP-w6NnB7JF1Z`07jT8QYNyX7?$Txabj1I zuvUI*j!-MWU_)n?M$qJYC=UOtEhf^q=*hG*UkE;?^Z;B)CDhYc<=TZ zJ1UGx%PI3+giFW7+gJ@ZOGCQ5E{Ca!4e1~2N*hd8%$HEBCN}-lZF3LLHi4L4$w$Hw z(9tr1E_0MkCV0b&-f%|`Ko&hFR`x0)QO!=97w7ZOxt6S(RP^p5gnt4sT7l?6#3Nc< zVZ)^IG5nAqIS!v)o~h3@=J?x5r=fb@hs!)|BB{$Mbs;!L_(I4p5MB!_M>_5{q%0i% zvhjjH%lx_a+daI}k8%#4h9NI@`yHRL_oE=RryHWSp{0SjILo0G(Zds!d6Wx;VByJw z$aLnAVPm!@3M2u&g;jmV6CtlrR>3woSWwB=Nez`V@b2<=2dMH%&f>2)(LH*RQgthO z@q$t*KH*X$UOpI64E!5R1EXXLq%J2|5I@tIhIMVyR5~haS2CklYN$2;Re!N&U8VwB z9mz$`L{NW=Goz5K;@a)%Yck(Gic@p}u{D7T7@jR4ye)1aTzBjGL&?1)Z8=Yp^7S)h zOX4=47G~^;%62F?hUnE8`$7 z|Gr?vIo#*$-7T4jKL0cV?$9N(I0X;%dO;BMz)_3CGY_Z3a*_l8py(nR*TKPLO+^UI z%o|W;y3-U2g~Om>vf8Jhf-lG*i(k&=vSrJjS4P-8{FLi-aW^kAd61`tya) zErP6Jr)CydTH!pWunDR7%ETDk^XZ-1Et95)d$w|Hrh+mAIfmU(z7p9lvWv05@Ej;J z3&nY52lp*d8P=blb9PgNidVT%n{T6p=UJz_KkovW5tQDe4zf90o6+l5*Cu6c6^j97r zAG<)Et4FZEo5)qv9$_U5NzowXNOtMMh0yCwSfrFnpQqRum!C_IKm_dO;I}JiGFs_$ zNngZ|SkQm?nM5na{W&>nT42}i}`<7|0k);%)<2l zPAa!Sv*p-ebJU=t(v!?dUdL>UN2BRQ>W>)WuujHoqp@qd{`x@@sZZ)1x$Q&MNz8+q zdm}&1eJ#EH{JrwlV@9v*W6-tj1AO+@#C6NN8Q&PN>l=5(iP8u}{sF7BxVVB14H6{c zD^x&CLR&2W0SWm{MrrB?CqYc&m~lV^Ar7$$2uq{ZDxT$&=R&wyMTA2^0fUK@fs2#| z3jz@)R@xI3;}StDFug?j4QY7?N;qg_NKR5sx;YFF`rAXOaPZ^U00cS`otT(}&x}{3yc=%8xqO^@Q%unHzk4{3_%FK00jjnTui6E z-?kqHgokVAR~D4e1|-6JcFiqk5cG|r0|=Ne*mvjq$XhxY%mt%~4GPTFg)!oNaNh-} zJIW87g4&w?h&!=ckeYwZl*nZza(p|7OMAp1?TrH105f|;rL+}D&0_eEaz1hxP$yxM z*94T4dbHPo4q=a1)Jb*Js|$qi!i3P?yPv_teZ;OC-7nt)T2wfj;79k!4IzEDm;RVW z=SKq$AR+CYK}#uLg$3fFy=G5_7(x&*5K-`;poSVCtLO)P-xJ+E>F_U%rG1RdonV4Q z*zNFrNO};f$i~nT-y{#h+Fc=_KSJ?VXO0zz1IR=`K?CU_Lcvx8FG-jNfZKD%4O>7Q zzZaNDsy>X!JbqA+o0XZ~@66(n2`r=#@6WPtx1NvjHyQ76p3MM_k9q}R&@0%RT};p$ zI5=1^u~2c4A~ZCR-f#CJ6U0|4*c}I1_6!1i;#-fp6Ut92gXe&_{Qdl;9f*%MMtUx9 z^L~&xAelWB259hXFT__q^e1ETckk=h;o&#O-gkCFBObIbT z4IUi-SC-=gTHjZ?HO!Zf8GC;#3g_|nQdMEioDDH@Q^ePX1dIyq9&GDUP=OFq0ODVu zafkseR9Ighk0bfPN-o$ACJ5NKWW+XY0{YvwP|@)%BPLEa$2Y+(Dgs2?XNy5FX%UDG z#K3wqN+cnfFe++bJcu`{U4LGHJX2skGL&SYJjlt}2Z*~P#BMz}=D)p9e4~BFih+K> z^(Nv38r*WCLEq4RMh`)Ne9-hJq68XTa*FuOy~NJyvjvbfWB)6w!TRby8PTA@Uflf2 zgh6_@9YR}K->{_%GAVmed4eB%rC_F--Q9&1PwIJ(1XYZhIc><_G)bh&f#H@_Q@v6` zD0*Rt0|1Ed;7g@|NbxV!Z~n1w0Q?8NJ6Q2oG$YAF{YL=8>~OF@6?u%r$;7$GUT<7J z@Ci8*3FHgANHLx0!{AFS;8bsG7VmxoLa%ho0o|3-9pzcj_d{iH3nc)jfcmMIzv%I) zSD)b~AH(%EL6DdSc|?%7^I0K4$W=1nm@J9`=FP@C;CznX@e2`h7GjkMMGy7EBVtzf zq4+fdkefH*z`ni=`RUmIRsB8y_AT|@^*nG=Ge-s*^v#TVGOt%)A3#nOD3Bxwhb@Ht zr9&G$4F&5S9=N0Qa-AaX@6>m-BS>yZCH2t#>44)JlAvT$GDs9RH};``=tpr^jE}M- z7ze9|I}ZL80lFTsam_6<@^Ky{5xf&AxDj&I{Z3>O{j~QAEf#V6mW!Enjwta#u;0so zk$?xb#lL94De%_%iu`r{2o=KLPdtz*%_T*%`kStrMd`{j?eg~cDH>zSqJms%ltz^wwR#6uJ>2|H!<0Y~Is+jDS zC^8xz)d-SvyqrCa#y5co@4M!2FkcGZrhLKAZ9c`*6Lbu%(+`!=5LhjR!nO6z{UZOA zR*HA;Vzm_QEo&U6zn$xEC;eu0k~_+xH!etcro9S$%iQ$H3Z90eBbb9yk5DR5ev}2B zDjK+B-fNc5V%7@eJ;_mT$fS?gg^hZ3mP%THj_+Nnvi z$(L{v978aFN3yXpL^!K9!m+OHjWQMK}QIse7dzM>Q z#yD68!gFP@#sQNw=ky&^S5KWQ3%1ROCkBpeTFE87EC3n6(M1=c;WJ>TfJqE7b2Tv8 zfNLZF%v}P=2yDrRr|41~<`W73^+%U|ce+Dnm#)BjMOej+pA2FSZ!#N8i5*k42}Ppu zzUyy6JDcJ?$)v?K^0TN0SgL4*sK6zh&f8$shvTn?M;1(DF7Mr~zxjmgaAenOTN~Yt z2d@&!;M>*Grv3(u@wMcdkL&_}Sts2fgGcE|vs$4fU1k(+v_l0>Gf8` zj(@TKa)*+wb4##}okia-W!Ji^G4hCFnnrqMk$(B|_4LuEcAVAeD-wGQ@DKxRiF==> z_JsS&srFkQ?TX~7%J99|(#MyGDz%OIj3_3h-<~2HalFur?d2?Zfm0E|7DPwQcCNMXBb=x?b5%k8K9JJ8 z;(Eo4bu;W4y4ZCB7*|4D!*C+gPN`_FMRcDtvOT0cApJDmD`=Tbo*X{UQ3h;V=Rd7u zOCzps|FJ>|R3aXcD8Tgn-r2&GL{BjzLh0zxvHH^I zuplBqf1`bX=*6HfWD%B)Gc=oq*SK}Lvt!F-ApN1PKNup2nX{=H+=nytEb^NGkD$@*f-ybGl5*!cWW}x%4u}3 zC11@5`KQ#eDl~HHj6N!Iis|q$68=^&K7x_O*QuPJs9ZVcPx9%0P8yciz^&*z&)jv> zm`DDPPDF3);70+*&NX9)j{~nU*T?Xb+6^KbFpM@)-_hi>;$>}qjIZ8YTfxtZywV)Z%<4{{I{_P^1~*V0|0yO^>Pz3f4RjcH&#Gh()Ikl#gnTP^2a07(D@7JX4QJ5cut(jmR=={8=;(ic*#(H94 zPWSuyRK(-R{_5Vp?N9Rl()YQj0E#m4N*{^jB8N&kQEA!o--^%$U*ig-*l7J2oH3Ho@7LaW7Z%q9~m8t}*z@3oGIPUu! z&)WrC=zKzjO{DOrHSMs_Z|9Dfrg8wr-eDZdKz#=2eY9dkS0P8hncF|*&h+Yf6bw3s zOJ?-AS1uJ=9avYz8Q-I&ZWm2C;ULDmh%H<2dqc6?7S-+Y0*&5FQ-n=O!q|*5=qtA$ ziK;rZj&V^r4g@!N5HGw`w1gIRDK9I|*7FPn!!>3<@OWxnMw0=XyB|-6+#MyAv z!84p8?mw?s6+6;~ozF1v%JWUz&#`XLxU44wY3c%0nWl}^O+S+?R*X6cmI$eZfcZR3 zw-LZ`{F}3*BOCkEv9pGy9Ngpu8+N2z+mhbm`?N}Gn?KE69|JvNP!!JM$z!cV+n*-a z>~(EJkt+gU7j(^la)SE#TyZ=HGna&QH2;eJfnGY0bhG-+h29~lNYY7Z+BJ;(HJa+7 zOTmrt_QO{s4uXv5+Ld~=Wg~(o#0!^dopP$3!L(2Rx@4-w`ef^VmEWM7poZ4QdM4>Dh*>FH)yfCNkXWllp zMk#9o_-0y|oZ*360KZbbWJ8#6pzPGL??Y1%rbB8!94-@aKPh&ViP?DPyg1;W^shS! z=NEG)aLOmNgh~p=Ko{xuvu8K2)ssxEqHEKVT10FU={>K@r;`<1_;aD>@{ie`z>-V;H-=WE^PL89Ij|7f}mKPupfRVB2iR|4@&T0KA_!4g}mG*v_Eu<5vo zw1T7?M9|~$S7=2g>vH^_y*SHSK5A=&E+g(yJ-`S^bJWk%SG^J$0Z{O4s^S#YZr-m}IlKeIO$mMItX7;-?n3vmKq z#UV=a-QI)?+!ORn#2RmP;2)34AvBt)l_v}9)cxnxB%oeAFZ5sTuOCL%Fm~lyqo%9; z=z}LG6TEx9=giiO^ zDbyU8Kr2;`eiW-Mpu}Bf9bE2BV1U{kzy_X6a>oB$Ol&A{hY$`m@z;uQy=^D zE_E*Cx9Lt#-Z$j+#D<^}O+D9}UR}UT_78iu_tEq$C4Jnd%j>onqaI+YP5hiA)u5T~ zOc#=Rf!8eGi^=@i)<@T9_F6=U`MieKj<+x^C~*D)r&@xvyl9Wl@9aN~ePfU(-IMjS zr#)@kcK5GsPusR_o71*!+qP}nwtM>RXLtV_8}Dw!Zbf~lth)DBMpb^u$a8KU?MEr! zoBW*mQ8TG0$RYkw<&M*6I_s@lPcdiywA8Hqcy3!4e8?D;7Spa#@Tz8qTS=}*g9BpH z{0LqiyX1DCAO)JN0Sh681O_MTcB&k;kN(<5SF%W1wtU>*Smx~-JV|Fl@hNTNdT+0Z zLy)&UoBq#bIBu))e}y0<)c#@zO-++D%0Ke}lf58kqjL8)psVy)Fm+#4tKq>DdN-gY zct#3(AExO5R(UI1RB~NdCe3x-mQZ-f>^hOUGKX>%IGo%yPC}3!xKmZX+bphUOwrm4 zDG9sKgIl6(x78o3F(50P_Bgq3Y1BW}YOuuk+!XseC3~eFwq_7SgDqTR#6_AhliDsD z-ZjJQK&kX|cqKiLWbSyLVkZv$W^d0DssfX@no2%btyt&)LncEzw21;{R4)OSX$=Z^ za50m&QaHj|l!yO3^1iSDcD#OlpMc+wRX&;yQhGyt;To7|;)*3{j45ynrDqY_Yh`jz zLcern={~AYRkxYFk}iMbf+s{@0`SCiG$(GW!ANl06sWgp=LxyRod8NK(F4&^uiH*| za#akxe4IUnSCRF9(RoghwQ#Km|3xLe#Wf|{zwlYD!!~DLuk^}|?}K@gHa!eSv?7gU z@XdnXA4{%f+Q1xl7pqlj_@koLk`c43m9Dhm@m2bzyq0z9#7tim3moI?dcX6UCbD8n zBp5hYZll>QBS?uyVze6-IH^iw?;UQSry0Y#i4=1eLrr{zR)B?ki9`Y!WSTota$_)b z>2j-(?r%*=%Ta7~QGiG$`;DYEj&pQ{zGN*EX^)zG0=ozTLzB3Y`FAY@o^k(-y`4vR z`bVSAhMGxtlMfy&N8w$3>ULkTfmqBCY0rp5;&*Z zgT^7xyBQ|BQWZb2K3cHLcmwYsH|O5Iu(BmqfL^;gSPy;$4|2gv9-dY_u87on_g3&x z`?{E+$;@KuFeQ&~Mp_P%{@~Kxmgfotz_CU3%Jyu%X?Z6rME!Z!pam$e?^)FcivQkp zLh5eFzFv3|Y68Wh;H{M`lGFF+o;*N=UYvGgyscw$cCZU*O2no>-R_J+t z$wf%AWcUFIUmmRpa?9_avJ7MS7d+FmM!lCGaA~X5CvhQ)zUq&mjZt`LS-j2l6^(aQ9<3+&U%?i<;$M}(lDYwm6t^(oo>n$)HNu~r!|II z*-RfmpDu0*zUu1oRc1@Tj(cBzm;jE#^z{)P)F=B&`CY=A10S>)a1Cld$#Ekkgs6Xz z?(<2U}dW zW>==k-#&BMLxL}T(1^Tzpr#EF={OU0^2fvD&M)(P^(H=7K()bFo$ELJjj~hrmWib` z-$FOW<^i}r*sk5`-))ECBnK*6o$68}twnm}fYx%qj|Km0NIx^hHB#Idg+>5N`%Bk- z-C+(9`SreyM=KM(A3EG276R22@vl?#yHa`pAG~DpDeEKTN}lfDwc=aE)qYf&s!Nn! zw|&8#t+ zAC1?pc(ZLY;>)7w>P-VB!mvH|rpK9%BnzEhuknVnJCE-EynH8)0tIOVx3J3`PihF) zLWYmWS~K!7vk7k#^uNe^*k<<-#YE>z8BW~qr!*>r2OKQBe~V?OQRhzWQMEf2HnHcY z4w^0U*nA~MS&GOQ`W`ICz5T`3IR}Uqrq@@gmH53J)(g)#-KlW4H435^idLT`M;AJM z(A_Txo9xp#O6%A)jCP~%5PLZBPt=VMq#7g$T&fH67FR~Rpwq|vDokwQ27#B@L&S=w zJ2+7krT;Tm%rzKCjEIgDZ$^RrHN#{hF%Y(0a{Kt#YE#Sz61Z?svo~Ebw^HlR85zCq zRh+h}1_v`&@Pg1vgGDz|`}!5J9a-W{Mk*4(RTB2X`XHrX*Asc^M| zYeBl;StntWb+Aum{!n~vysx>P5@+13U)f-!^aq}PXx<_N0z_x-muZ=TAw6 z??9_kXJ)!aNVlFKm}{&btqMaYkgJKu@7a&sy>(rV?T)11cxzN{sm_=@UN|@;HZven zdY3&?dvuiO1&u@!8>E2{*cA`)66qU6dPX~1Q-YwAjkQEu>A|UQBFvtv!9xBde=hANN zdO;|UI1s(5=i9_QW`G2lifFpP5myN^Ia(CJQdna(CDs0n*nygLIx#7zomFGHo} zOR+nqeKrcoFSNyJKe7fH@yWod)Cav*CKCcR@UTx$CA<%J{k&hsAG5Lc4j>=tp@t_W z;#g2JMCYnord>x|4$rFvr=0}+U}J~L1Uo;|(lXFs(1ty-mxL$OY)v_e?I9(L^XV_D zc6lvu1)ZMSz(5gRQdX|YLA?kSo4s_1tG%Dc1ia!h-Lr?XXA`>j*h%eGswmoM$-kV< z{QI`x2WJ^;8v5_se+z9_fans$1;0@HX=^^Mc{c)5Riqk#WLDx;`z%k7KZeg(1`!vl zPN<+_N~J*~JYeB7^Y=KGSm2Mt5)HZ-*AI)9m1Q;zupVmJUiA-HzcpLAk$-E0;&PEn zKOo_zM*5WUA7=HwOx-7Pmv>*WqDWT#f_R(?>3}d zDJp2Pi39XPpHv-<8dF$%aN3{VVZ$#-wQ>^tCZ==birrl=V?8eiQpJ1MBta$;`&X)N zv&pWlS_B-=xudUR37Kg`s9!$XR(PZQPZO#(O?>$7?p=sS>!Ro!na#xl*%FJDSJ)B= zB}WiisOliq#+7yi?js87#UkNvYEf_`anm-uK7Ub~mN+er$~q|t$eAU2u&GfwugEKV zZdZgGn89qB##EGs(|v9Pt68`ie z`k58%cOFAg9^qq03fZcZ*nP!^je~qm%JLJf@3;>6EDrqVtbrBW00_rE>Gvp!+7R!0 z@ak*8Olg`uSBytIiD`x!6#~s0%U&P{=8e4 z1uc@1G-PkP7&7lqK0zroMmq}sGRqqU+Z;hwB;*4@v~F0RZHZhDZ||=G@ZYm4C8!&f zHI5PvW&|rqZr&K!x^SPkENo>T@#S+RcZU&?Nin>XTof`?pH|!C;aAoW)^+}dq(|xr z2F|IUTVv9snfWz#)Z@?t0Iyq>2*E#`TDrnKt&$~wSLd66*w&fQ1fyqi@+ib694_+2 zxp48RReLibyE58TkdzVWElTUcTxqstQXMgc>iFzKnQ{GWIuUhrqE?o@drRr{3~A_AFqf4R!gX$uTwO$Ubum~-e-M~HoBF&IGHq64Z<}=UrddA{ zue>QKVYaHKP*s3vxOf#G7?fFA)Gv+-oUkjq-b_x z4OPZGFeE%t$!!?9=XPK98GzaL$#cO~P}wyia~pUsajwd{miWGtCR>}o$G35MxR}c| zVaXaS*qKtx%^gB9$N zm{+se1+&VSUlhvxVA7h#-%S^_s-E90l-`|&&ucYL4!iRr>{Sh^i z3dWDlFsWWk|0&Gw^kQ$$d%|H5M&X)1&OQFX-d(QToDY%P*@a9WNnLR-i^CB@OcTNT ziB2fozH2!?&$mH>0SxsReG;h@Uh0<0ovWsAFXJL91%<7rlUtE1@G9@kY*0s6Svu+B0yuTi5DYTC(H#sq; zL@160P2Zw*dz1?siKKefP-sd_!X*VFp+=lZJ$^gXely_ZB=+pBk#>s|`-z|Mdn1U6F?ayYtYucy_=LcYW- zOe9s|$z4@}pZt1rf9j-7DeI&l{kn;gJ|6vXmS(8*SotpH&65#NDz&!+*gj@-FDtYJ zqD$hbekP7Ac|eokb9cn`Vf^y`OCuK+Gh~V1YnY>_`pd;KTAxaQn`!u4n+BSE?SZM| z5OxFHHT7u)s=L}#{#Bc=`E8f}`O|aybQGd3Rrxe>F3Q0jBjpTvgv2vmL^zDz>u-L7 zEQDRT>5zyvCi44ck3TDJ4IPcwCPP8W4nlA0NjqG4R^}B8+MU0wID?0(mrmSjqYA)h zGg_Bmw@G20A{GPiV)YgFG4UpY(s`ZXN|Z`9`+lK~_J`ggcD#!SJTKAKB4#4+gva#@ zq8Gbd#5A1gN@2G*$^0CcyCbDNO{eK1?-l2v90r6GYBV8kBU9~*-rWeKnaRw~wHakZ z((e?Zd>)Rt8?xD&>=ZjM9r42)1KaP0Bi*qJ=2EgHras#O!=Y9ypn|N3fM1_atNcB* zRH0eh`fM&C=?73(t%MHa(o4}l@jx4N=w!#eX_x&aayx|$_g7}AI=e9PC>Y`n>Nuv! z>SPQiNp_}?`+3EP^aC~NZGK%+lPE#~z~fbn5z;PV44$5jbRe|3DPttr&4_qjECLQq zEcdYE)g)f+_42S6ZwMZd%Khr@TP&-p+KD1oT4#%vz|oe%!SUb+)4lj&kGsDntd;F5 ztk+CbUnk9sWAbUW_nGURz-qDEW>Og;SD<-DqZ-(mFN5huJ*EQ+f9y*{DmVtkvKKw4d_#EHqok-_aY3SaCgd;1A-IC7kizkBeI0-ij#Z&i6Bjs4!RoZ) z1MNp_P}g3=2DOOM%_d9n!p;*uvPfz~k7me6Yuf&3ba0ix7;h0it<aytIs<92!&vXN4^j> z(X>z#%YR0Bai{f=;)dve*z^1|*0~IIbmao&LR}S~R#iuQ-#y$M2PL=lyyx9mIfypA zH5LNrE}gc?U@b$q@ zY$8#o&QYNO#7d8$2Z$vYMF9#h}a>VPd}kLbdJ|#HlSSF4_oK!I$7cmH}Z6wSDWZqav7^Jo6WPK zgAxY}2WZ$9ePBsQ6JB+dr|kPkMebTTC#u~ee&PmD;C&1>3WU*LzCTM^^@43A6@)w^ z(z$iMkgN*qsEZ6KY9-@4uykbdDolAw4~&5?#UbEk3UsbaUC22hZQj` zgF0lqL|p3qIaXGgZ)FbU6PI9h3I}gMme6T9%UE}{F`D$bGwOMa35UvM7C(EqBtdDm zF`8LaTTf!sAhHA`xWq0W?v_1*F$hBCQ65?A%>Wvq*-_OE?eL?$LUW1gIhYQswg=UO z8y+1}3)3AuvbD|$+i^Rq*-f5%N4CH}nlGVw1$l?eY0+J>qv13IQ*4+K=Npb;cDZeh zL*gN`VeAK(YC2^S{|@0Td>I%p)z|0j-Fg?Sd;#smGAjO0yy0&qFuskxITRPyznH=d z_zX<+tpBnY@fldy|5Nbjzw(9|nVA6i|8_vpiI`bB8rkF1iCF468VMO0*cci?@$f)7 zINBTOSwXq3MJhl86y307n&xt38rREez7q0M%H_}xIZ8C`OOewJjw0A6C)f>+CL$nF z#Lt(E#1pO>ex4FG3a>aKEXB!|Rx8mK5>n3&yMS*#y=NW2XSroDeSN+E^}hb<{Lsz^ z%i1z_)};PvY(Q=;LZndXo8H`s6$w?M2%aiY7#|Vg`AhSsPeXjfQa>Vvf3C6)J~lCZ zAQG$SPZb~rr zz%UTSM^lJh3;$5a;sfwpd*xLLLt6Qi7;Qs@ZiLJX;}C9kiRSD=*oOL1VnD$I`9p1W z6(wX1$^bdRwxPO)>N#R}IAiNVk*0x|8m<-FB3UZogW?bgV#ARl3YH-92LQn% z^z{UECPjqo75xxsrNk#r&y>4f+sJ{8)}!RSpOMv?mvvNBGeMt3h7nKbBt zzK4VnKzJcJyv&9e3EuJ(0)pR`-an2)Pe0Fv6eBGZoUiQn&TG?O5Lx#Xi4jj1(!R#Qah#{fX`>p~bLby7%T5`DH zNzuiU52prWcaX5?GSs1vFC0mnBIIb`L)k%BGDh<310hd7<6aSW+lp0Tcf3J=pCeWn zb8RPVxZqykd5HxA$Ls>*fB%&H3%BwknyvzCLf9~`+e6DPbOnf$S@osVD>NZ8uuoG4 z^!R4jh|xF%^3i9~Nq`+)rIFOJ2+WrlQA|7!Q9TC<1Uet#eIQ71*zhO0A#y(?)UWZI zpFRD=#EW7{)jyD368}6XsYd-KBxo|Qv>!;vyEZ8Q*`G@vvheX^Uscqm^Ou)bO^~!YQ*!r?Cd(GA}qx3M_YT}knxX;(LTJ?!qzOa9!Ly13Lc5v~a z#-v%7qZbri$s%)ybJFAt)u}p0r`2R6Ryr^SIh*U$I+eByvRBh1>2`YXLx-u@wWBdj zR~&E5un(uz=pk+0(m~q5i&-0$GJON7DB5}<+VOgJb9uMUUYpq4RMU}D98debm--+# z$NjVhyuQhOdR>sEs4gIaO9(7rphmH+#7uRk(#qGxvv3-2A#OBER z^q6oq4sVMj7MMlR;0ACOlZX=$qo?=Er6~tC+ve2zI0Sh*RsAjI%h@3ujd**^^RCJ^ z#eJKq#LpFWdf}}Wmtji?>NILo#~c)}LYz_VzG)8I?;X&MgN`lwsUn!{S*5#fSrf+W zN|Oc^)?1j*6;D_AGQ6)jM$bUbqT>b>*Qa6!Tu#u28WU^H6QXJw=8NKoz{y9M$qBWG zor9~>-kqDC_ttT}uOt^`9vHJNqtjNn>sq)xpB92S98r@rI1ketq#by^i4dI;sUP_2UN-eqRYVU_2J_DzNG9ND&yQyoZV$sQ^Ft(hv!P^0T?pEG#(dAuKJ*%Bd{ z&FYM8uqlZ72Q9qnz>P#(ZZt;2 zRSug;LC;h0ze~A1qvorG|FEyKasZ%1JI9QZud58d1+=y1)N8cg?eaKCh^ExoYO^0l zt`B(|THm$co{qj&i=Hk1pyklrjq220uOBWQ5I>%%Xg5zga*d-*_XAb0rpZVrKAgl_-+O0Yr8fLQs`tS)ITij~Ip>CAf$sjG$ueHY z>er!?x*S&r6`!uQ%(_Tq=UmmCLH=#D`C3%JLMvZtr-Pwlic8?lK!Z-Ju{OqZ!*pHA zL*k>PWqUhzd(2Ba3SGAvy>*m=I-)ueMWWyhd3IqUx_pHQ(_8?H zEM&i62h6QmGBzFfDLNXeNXhseEQ3jGB5NUSz~KRN0 zMM+9x+oaO#!cZ^hnL^oBakb}ge(B*5k8zx;{+=h4cAwO~et!*<&1NvU8{=w~NOiVW zvVM@4G-xS#l-lc3S8nMM=sNP2j%Tg1%E*9gohfb_%m{cf))XbZ4>1y;)U6ho-G3>v?12e*S)prqVZPc&$y#`e%kxcRT%c z+Dx8nGU&U(3AE&GC2lVx$;^ckHi}G)E>*hcg5n96*^T_PbL5RXN;udssamdSqTrh^D&nQ4ueoDa;p!NOazedZ9BJb&IORosf?_i%_b zjykwR&62I+O$T|RoRD}IK-oHYhMiai(@)53bq==k_5})&a{GQ~9f>LEUslWG#tqR! zRUI{ybxo!!xB8*Ab*8Bv4izDiT^qJ4(JQNm5xtG4oRpeS5O80O32Lwk#|@3dP+dBx z=qfQaxyqU|to1m~wGvX9Oyl3RZ8`@Q-0rqJJxv4aTEmWSAVoSBvLokN57`H-;IhUqm$PqX3-pXr zBNAvUOHD3BL3N19NJf(L#twHSY*zPI=<=B4Y+TehGR4Fb5!H|!&Fy-F@qyRiyn$y4 z=AFWzLDxpsJl5-yK9a9T&rs)gZu#TJjUKq~BC+o(yORwW5a({0O{05@QKAJlzrDrY z*t|z)aQ=tvkLAB4e~NClM)-6x`sNCbR#0@(_zd*)|KxS{4vzQ$7N&otgZRws3~c|` ztnX5DT>*=|-siYFW!T}YJm^HkC$AtZ;L-#(Jz0rreDfvgveuK0xtp@a^E;w4>Sez`EC#`a0I#1 zPdLFb6oI>%LfxW0dOtJ)3w-Dxddw_6Ei}hmJtaI{5>>IE8bAId^dXC&$oCV9pw9IW z4x!FLHX8l@CRQco$!7Eq0X#!wd#(}?^J;3qBC(u<7^Tsc`jRp!v1dF!z~6QZfvOu~ zjG==Y654F5X6S2eYrtUBAF&OYZ?K^*bsca|xagk|n@n}*YYfoigAl+A{OQV@xh^#9 z)m&Gq2ZVLMz@2xz^gMlSHi{d-a*P|}gnd5=>wmoOvLXXLQ)mIT_*NKGp|6lp`zx?V zajM3Z6S}Gb6GOBHfEfdSOJ9Z(wD?9Rf;al6LBGIoAV>#@0Azo(IYXP~6tm3u+6O-P z(w(W1`$2*G2Fas3!80X@TKU-rCY7knbk77Y2~_qe=Rzamg70x*X2ubZ&X9|WBl=I*BMY>P+n(|3U z2m8l&f)OA`0r()mo`J}L_z?gX5Nrsbp&?uWpiaJrp*diE;5hlOs23cnGdR}VfSH)y zSYLAAHFgLMzfUnZPC8wO9B1D(*OM7WOb&3fm=!|Ui`ae+jqZ=SLFw-3asSRstt1Ug zmv1S18{_%DfMy(<+WqgweVGsA6aXAp>_oJHt*H}@+thqs@OqkFiB8mY9?w;OB~p4E z+wg^H()@J>R~nv=H!52qW3!aZntAbSV~!#A&ug%CZat5~>;P}K56fcRkU>j(jkyXM zS2oNjQnG#RZqWDOL)-p(HTG7Z^5Wr7n|c$n`mG93n;t(J=O1;*-5>HbAU*g(WgvkO z#a*HW255~G$Hb=a_jW-idU&jTJYDQxHmlL$xY{6D;cPZ!`G3XPsd)Okp5UOI)xFaR zV13&(Jpa_W;M2GvneVdoyvg|jFMlilsNpYCoZ~Q_6-CJZg<*77`yp!b+bak+@eO#h z$%+IHhsn7&_i$rrq#21t#CIUHuMeb0u?VtAo|h?w-4vq+!xV!9r6N6VK1_4$ujL7~ zzeLnR@SXW=9NP!I8&l)4z)_t^jH8;!m3ph07}vp?c517dv4ZW}IRr*rlay|wHiYUW z9=z(vYl8)(GDs8j1m+GFa65s2kx?4Q2RW!kp2>|PehNhKVNsIk!^A?eg}K5Hjp3qL zUZ|dp3wwg={q;=9MbeZORMMjmy*jS0<2%f;{$$-aH6>%qVEK259s?sPyJKFctSX}F z{y5g)GlV+u^|8{5Hw*zK72mJoiejy&%0#Z!n`qVPp{1D;Q(UHNdm2%P4^jTbMCy3yP}|Vx0Xh0m=eAWWh~$|H z013x2q97m(7gUvox!xtunsr(^K=>zs_bC%*y^UTO*l6z;MJcSGb5f)#e+FQRMWBDf zO~>*(NJSeCA4;?K*3GH21M(4#AYAN1K`yE0jLyaV8nB;>kmX8VEiLS1)(G|2M3E6< zeR$#j;>St&K7CnzS(So?EW-1%ii5LZW54vWoN--Ghj7vF4~^HA+x& zfz~g9xPT0?+uW`W6Cp<_aIL{i+$Y)WPgmjKe8RyF?B}9TG{!(f+`y649uNf@689SI zJL>ZtwG)>4H|Hb3~o8FuQ3iHXs+0bTC-hK`0Z1{Tp}D`Q#p`nKEvHLh(O0(2m17JSBm*0oZ)E^)^M`~bE^XWH2Ib91s0cb-u-gMm9y$B zC-6fAD33W561&)^apVlEfpI(a5RwDTaD@?GAZF`zf4$TRP837umoh!83+Gjy(=%K? zrL4@os1rdJs!|F@#*ZC(?mf-HL;=S-svc@Helk`C;xhuv3LRhor|0uGU>__&LW89 z{E1cgD(T~A0y!T^&Vmwy{SZjtWuF8K`bB)bnxJtr9>2jW!f*TJkN82gE$#p^d~v4~ z4aSNP?tquvMIp4Gf>a7@O-m|m0zB-PtwJL4dSfMIZ&5B#sor)CMUTE#*niY>-JsWA zw6QiqmQK#v^732|a#xC6WwT?zs#Oh6VeXz9lRr%>%@~( zoFv5ynf}z}Cl!p#QQGQbQHUvuv)R>7vSPIA0RbsnQRA37KFCAiP*IbWocug!tCi1R z8giokT)JlcZi{wQm37CBcCyAWAj!5?Lb{yGh>2E{5WSB|FA2j_Cw~ef>sYp_Bz7EQ zHm0_IiT%lCL86dn0S;qQ%Yyy^ti?SCSx$}=<>l$JEt7_$@!_SXJ}8VT8`!(MRVZ!HZii5e*3P zb_cX%!%O33IGfeFDH0j(E#h2#V%`u9y7JDTOa^Az;TjCA(TI9q1|KDbaVVIzcq{~I zPDy>RYQsKPio!KRa{CYkW;sg2#-zFyWmNc6#}AgV8ForcYbDLuHM{F-J)Jz^0`ZNg zb4Q3&l>j2FN_53zlZ%D~zFS7?>kTgx`DWhJaXb7c`e#^!gdSl=MsJY()Xl!MD0-8vjg{5w-a1|(*T=>mLFCD%sYQlCs4iWJl;V-@wz7Gecr z!%NYz@&xLdN8{?KN`s_yqh!qFEDavdf6#6~Y#Hcshj%KX@#YLF9c7OIIoM^c0rrqZ zU>n8uGqSe*b3+EPr4SMs9qD>dCKC!EddO#}S#;>8ep@I!!r6IsvC8jO-#b{N!3T%E zOYFE;yZ0F}BQr9dkMgN~?r~4%Fc49fB1q;lyYQoIPbTuIz^x4P>6H=({qToCNF?8> zu|<`j%mfDWY1^BxT@layB>;*^+BwXSZCu<{JSSq?);_oz%h=>sWqOBDq1V&HLNT|q zDBhkOJ&?$vwSMR&20PQkn8wT&6<4!}fqUtRjI9mhkvuOT8iww2_K8bXLG#2Q1S;yTp4Y$Jdlz~&Ha>3%!zg1`OVF2-z<)w?aig8}+;LLOS=tF1He|K)V zmA#WzG5wamdlIZw6NiANyrub2q*C#*-^6C9v%1`yP4fPoq1H$`4}xE~uo^C31aHDv zOR(w_nGQ$%E%8S!*4A{_lm^d-eu7A^p-4~iNn*3)co`}Z)bt)QR*A1OtnU`NNb)lA zsqY>iJ@Fw*g8=E_ySboazgn6a&+MNs?iRirfx9GMfZLiXzX7c6<|=R|TFcUj=A@P+ z!{IWCqwVmybQ3>=(2Q^pHKZhNHh?&rNLf@P6Rn)x0 zw^izUU-TcAC;RSEiDt!71)KLdMlS(GJt~|5g zjND30e;jyN;1&c$SyFNJo?IE*S}vz)!RK#lo-?Ivs;fQfdrwGV7ap*DdJnqZyt=;j z4tJSmu6Iw(Lj3i5$>jBDz#!ymQcI!an3Oy<$yFuPRBn)9TI2><9m@d0TLH-S`3BWk z#`iB_T|SRqo?ry_J%88XfXDmJH{~9mj`A{ozvqiX#_rKQ!S-7+jST5bv{mCeySTtT zKk>thhG=;g8HQnKzH|ClsG~433IkS4Lvfz$5j3WM8r85nvr~A~+sD;(bXD$|azy;3 z?kRv9R6m})kFI`>+CoA$ra&Ac!B2pT1{K=bG?1hcJuY=1e>IvmqHu zRqeifjK(eS!=Y_kUisO&vxAmH$i+G23q0bl9wB3eeJsiCi8ebPFvIekt1Bm1_WQmw zGZo!bh!D3=DALJk7myXg;F{gr&tS)Q z0yTFXx5dkpJzAy<6ic!aH|Jg+WUA9yuo8yst6ldBt8{)Uj$|;aUVgW%_wck zVm@DQ2M;W1ucP8B8TAw;A-;OnK_a)eJOb}ipkFK^HEqlmV3)_)TOIlChX)EKad=^5 z3H$p#t2;N|jN;?z zyJYn64=L@Q9(TZjj~*|7LHX`JBMaL_^V!M;NLQjGw zltV=S$f(Wi`IeW}S{hWNlI`T+_H_CP9ypay%CU!4Ju`rD(dG#z2uuvN1uwh)!j++6 z_HWHQr>unTRQ|#F_p-SYUKJ$M`FP71q3?mn$aJY%OhbRpUhEic=v1L?y(b;EV=NTq zH&-U6e>KYB7LU){=?)8&_gZS@;M#OgAAHFt>-1ujIhqaLYH>o=WBtdu1$TLwl4~iT z^jM%i;nCB;XL(kG${aW23dhG)^5iv20~ZwDChN9{l?$EA23 zb_rgi+-y}&cezC`9&FWdL^z|kAW-g3g7+;~N2N_@u%dZRWweL2YG%9brxo{VHd#(B zq(Eyhe9s^1l#F*9KT<5Nw!wGHKe1u#?%!h^z4b}dNcYHZv9`BS%Wz`3;@GcRKGv@G zPM^>~Ek6HlH&$anRDkJyKrEo0!3TbKUg*0u2#;R+6)6%J)9)^4BNs69SrWW$p}C(-!LM12XA3R zydu4Kj=0A;F5AY>Hzf^`x^ge9Zk?D#Be?nkGRru)_#cXN%z*z=rIWR{F?2HchFZyO z4UH9zRB0G!ndxa6=_#P-1i!IXN1N{_-?#r|n%P(jeIv5?aBDQeV&7`X65uP0bwe zzt4a7i5g$o$ll@m)%Z-b49wr~F(WGr4I?eS8ZD$W^uU#;pNZe+`c|EDNn|8HMKRo=)LicZ|x(8v{EgZ>-Gr`Lj_Q!sNk`sWgg zP6c0s0iOw<;rph%jg2Ed12fzA67v7dFt+)&{t3H(EFpXiE`AYaHb#0@Ms|Jy0Dy@J zz{W2mC@jnmU}s}zU||y$;KBdjhkU>1w~@7pqbWW!Bg4O!kpB-qgk-i;MnMi8{N}m! zcxfpwNxt+aVd#>1uCk?47iEKf;Ufr&IncQ%OACwMg~Z;@&NoZ=H#uZLyPm$GA2T^M zY4DeC3;;te>zTTnYnuBw%j4QZSm-Z1q2Et-nY>@qoO-}^p}zE!F=mXyxG}{Az-*19 zGD339VuptJ@Bl%|aG<%`S;?Vy>TjY3;%9?yHv^4yX@Qq|d?ZV+X|8 zP6_Pn{}7KD%}G|p5R1o_A7Hjhzlrf;;0MHHs(H=)`n5fm0Ipqa+6FYSP5=jzEy@!4 z<6JV0u?O#cN)2G;9Llz9*vt~yrv_uz24>P$1lug!00nk@z_ej2JVUpNvX^8Y;=9US%S Y9bN6e!;cZbz{t!BMM5GhBLemR0K0!5$^ZZW diff --git a/openair1/PHY/CODING/nrLDPC_decoder/doc/nrLDPC/nrLDPC.tex b/openair1/PHY/CODING/nrLDPC_decoder/doc/nrLDPC/nrLDPC.tex deleted file mode 100644 index 019b51aa96..0000000000 --- a/openair1/PHY/CODING/nrLDPC_decoder/doc/nrLDPC/nrLDPC.tex +++ /dev/null @@ -1,960 +0,0 @@ -% -% Licensed to the OpenAirInterface (OAI) Software Alliance under one or more -% contributor license agreements. See the NOTICE file distributed with -% this work for additional information regarding copyright ownership. -% The OpenAirInterface Software Alliance licenses this file to You under -% the OAI Public License, Version 1.1 (the "License"); you may not use this file -% except in compliance with the License. -% You may obtain a copy of the License at -% -% http://www.openairinterface.org/?page_id=698 -% -% Unless required by applicable law or agreed to in writing, software -% distributed under the License is distributed on an "AS IS" BASIS, -% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -% See the License for the specific language governing permissions and -% limitations under the License. -%------------------------------------------------------------------------------- -% For more information about the OpenAirInterface (OAI) Software Alliance: -% contact@openairinterface.org -% - -\documentclass{article} - -\usepackage[a4paper, total={6in, 8in}]{geometry} - -\usepackage{amsmath} -\usepackage{amsfonts} -\usepackage{amssymb} -\usepackage{booktabs} -\usepackage{url} -\usepackage{tcolorbox} - -\usepackage{tikz} -\usetikzlibrary{arrows,decorations,shapes,backgrounds,patterns} -\usepackage{pgfplots} -\pgfplotsset{compat=newest} -\definecolor{green}{RGB}{32,127,43} -\usetikzlibrary{calc} - -\usepackage{listings} -\lstdefinestyle{customc}{ - belowcaptionskip=1\baselineskip, - breaklines=true, - frame=L, - xleftmargin=\parindent, - language=C, - showstringspaces=false, - basicstyle=\footnotesize\ttfamily, - keywordstyle=\bfseries\color{green!40!black}, - commentstyle=\itshape\color{purple!40!black}, - identifierstyle=\color{blue}, - stringstyle=\color{orange}, -} -\lstset{escapechar=@,style=customc} - -\title{NR LDPC Decoder} -\author{Sebastian Wagner (TCL)} -\date{\today} - -\def\0{\mathbf{0}} -\def\b{\mathbf{b}} -\def\Bbb{\mathbb{B}} -\def\Bcal{\mathcal{B}} -\def\c{\mathbf{c}} -\def\C{\mathbf{C}} -\def\Cbb{\mathbb{C}} -\def\Ccal{\mathcal{C}} -\def\eqdef{\triangleq} -\def\g{\mathbf{g}} -\def\G{\mathbf{G}} -\def\Gcal{\mathcal{G}} -\def\h{\mathbf{h}} -\def\H{\mathbf{H}} -\def\Hbg{\mathbf{H}_\mathrm{BG}} -\def\Hbgo{\mathbf{H}_\mathrm{BG1}} -\def\Hbgt{\mathbf{H}_\mathrm{BG2}} -\def\I{\mathbf{I}} -\def\Kb{{K_b}} -\def\m{\mathbf{m}} -\def\Mb{{M_b}} -\def\Nb{{N_b}} -\def\Nbb{\mathbb{N}} -\def\n{\mathbf{n}} -\def\nr{{n_{\rm r}}} -\def\nt{{n_{\rm t}}} -\def\s{\mathbf{s}} -\def\SNR{\mathsf{SNR}} -\def\y{\mathbf{y}} -\def\z{\mathbf{z}} -\def\Z{\mathbf{Z}} -\def\Zc{{Z_c}} - - -\def\herm{\mathsf{H}} -\def\trans{\mathsf{T}} -\def\EE{\mathsf{E}} -\newcommand{\sgn}{\operatorname{sgn}} - -\begin{document} - -\maketitle - -\begin{tikzpicture}[remember picture,overlay] - \node[anchor=north west,inner sep=0pt] at (current page.north west) - {\includegraphics[scale=0.5]{logo.png}}; -\end{tikzpicture} - - -\begin{center}Currently Supported:\end{center} -\tcbox[center]{ - \begin{tabular}{lll} - \toprule - \textbf{BG} & \textbf{Lifting Size Z} & \textbf{Code Rate R} \\ - \midrule - 1 & all & 1/3, 2/3, 8/9 \\ - 2 & all & 1/5, 1/3, 2/3 \\ - \bottomrule - \end{tabular} -} - -\paragraph{Version 1.0:} -\begin{itemize} -\item Initial version -\end{itemize} - -\paragraph{Version 2.0:} -\begin{itemize} -\item Enhancements in message passing: - \begin{itemize} - \item LUTs replaced by smaller BG-specific parameters - \item Inefficient load/store replaced by circular memcpy - \end{itemize} -\item Bug fixes: - \begin{itemize} - \item Fixed bug in function \texttt{llr2CnProcBuf} - \item Corrected input LLR dynamic range in BLER simulations - \end{itemize} -\item Results: - \begin{itemize} - \item Size of LUTs reduced significantly (60MB to 200KB) - \item Siginifcantly enhances execution time (factor 3.5) - \item Improved BLER performance (all simulation results have been updated) - \end{itemize} -\end{itemize} - - -\newpage -\tableofcontents - -\newpage -\section{Introduction} -\label{sec:introduction} - -Low Density Parity Check (LDPC) codes have been developed by Gallager in 1963 \cite{gallager1962low}. They are linear error correcting codes that are capacity-achieving for large block length and are completely described by their Parity Check Matrix (PCM) $\H^{M\times N}$. The PCM $\H$ defines $M$ constraints on the codeword $\c$ of length $N$ such that -\begin{equation} - \label{eq:29} - \H\c = \0. -\end{equation} -The number of information bits $B$ that can be encoded with $\H$ is given by $B=N-M$. Hence the code rate $R$ of $\H$ reads -\begin{equation} - \label{eq:37} - R = \frac{B}{N} = 1-\frac{M}{N}. -\end{equation} - - -\subsection{LDPC in NR} -\label{sec:ldpc-nr} - -NR uses quasi-cyclic (QC) Protograph LDPC codes, i.e. a smaller graph, called Base Graph (BG), is defined and utilized to construct the larger PCM. This has the advantage that the large PCM does not have to be stored in memory and allows for a more efficient implementation while maintaining good decoding properties. -Two BGs $\Hbg\in\Nbb^{\Mb\times \Nb}$ are defined in NR: -\begin{enumerate} -\item $\Hbgo\in\Nbb^{46\times 68}$ -\item $\Hbgt\in\Nbb^{42\times 52}$ -\end{enumerate} -where $\Nbb$ is the set of integers. For instance the first 3 rows and 13 columns of BG2 are given by - -\setcounter{MaxMatrixCols}{30} -\begin{equation*} - \label{eq:33} - \Hbgt = - \begin{bmatrix} - 9 & 117 & 204 & 26 & \emptyset & \emptyset & 189 & \emptyset & \emptyset & 205 & 0 & 0 & \emptyset & \emptyset \\ - 127 & \emptyset & \emptyset & 166 & 253 & 125 & 226 & 156 & 224 & 252 & \emptyset & 0 & 0 & \emptyset \\ - 81 & 114 & \emptyset & 44 & 52 & \emptyset & \emptyset & \emptyset & 240 & \emptyset & 1 & \emptyset & 0 & 0 - \end{bmatrix}. -\end{equation*} - -To obtain the PCM $\H$ from the BG $\Hbg$, each element $\Hbg(i,j)$ in the BG is replaced by a lifting matrix of size $\Zc\times \Zc$ according to -\begin{equation} - \label{eq:35} - \Hbg(i,j) = - \begin{cases} - \0 & \textrm{if}~ \Hbg(i,j)=\emptyset \\ - \I_{P_{ij}} & \textrm{otherwise} - \end{cases} -\end{equation} -where $\I_{P_{ij}}$ is the identity matrix circularly shifted to the right by $P_{ij} = \Hbg(i,j)\mod \Zc$. Hence, the resulting PCM $\H$ will be of size $\Mb\Zc\times\Nb\Zc$. - -The lifting size $\Zc$ depends on the number of bits to encode. To limit the complexity, a discrete set $\mathcal{Z}$ of possible values of $\Zc$ has been defined in \cite{3gpp2017_38212} and the optimal value $\Zc$ is calculated according to -\begin{equation} - \label{eq:36} - \Zc = \min_{\Z\in\mathcal{Z}}\left[Z\geq\frac{B}{\Nb}\right]. -\end{equation} - -The base rate of the two BGs is $1/3$ and $1/5$ for BG1 and BG2, respectively. That is, BG1 encodes $K=22\Zc$ bits and BG2 encodes $K=10\Zc$ bits. Note that the first 2 columns of BG 1 and 2 are always punctured, that is after encoding, the first $2\Zc$ bits are discarded and not transmitted. -For instance, consider $B=500$ information bits to encode using BG2, \eqref{eq:36} yields $\Zc=64$ hence $K=640$. Since $K>B$, $K-B=140$ filler bits are appended to the information bits. The PCM $\Hbgt$ is of size $2688\times 3328$ and the $640$ bits $\b$ are encoded according to \eqref{eq:29} at a rate $R \approx 0.192$. To achieve the higher base rate of $0.2$, the first $128$ are punctured, i.e. instead of transmitting all $3328$ bits, only $3200$ are transmitted resulting in the desired rate $R=640/3200=0.2$. - -\subsection{LDPC Decoding} -\label{sec:ldpc-decoding} - -The decoding of codeword $\c$ can be achieved via the classical message passing algorithm. This algorithm can be illustrated best using the Tanner graph of the PCM. The rows of the PCM are called check nodes (CN) since they represent the parity check equations. The parity check equation of each of these check nodes involves various bits in the codeword. Similarly, every column of the PCM corresponds to a bit and each bit is involved in several parity check equations. In the Tanner graph representation, the bits are called bit nodes (BN). Let's go back to the previous example of BG2 and assume $\Zc=2$, hence the first 3 rows and 13 columns of BG2 $\Hbgt$ read -\begin{equation*} - \label{eq:36} - \Hbgt = - \begin{bmatrix} - 1 & 1 & 0 & 0 & \emptyset & \emptyset & 1 & \emptyset & \emptyset & 1 & 0 & 0 & \emptyset & \emptyset \\ - 1 & \emptyset & \emptyset & 0 & 1 & 1 & 0 & 0 & 0 & 0 & \emptyset & 0 & 0 & \emptyset \\ - 1 & 0 & \emptyset & 0 & 0 & \emptyset & \emptyset & \emptyset & 0 & \emptyset & 1 & \emptyset & 0 & 0 - \end{bmatrix}. -\end{equation*} -Replacing the elements according to \eqref{eq:35}, we obtain the first 6 rows and 26 columns of the PCM as -\begin{equation*} - \label{eq:39} - \H = - \begin{bmatrix} - 0 & 1 & 0 & 1 & 1 & 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 & 1 & 1 & 0 & 1 & 0 & 0 & 0 & 0 & 0\\ - 1 & 0 & 1 & 0 & 0 & 1 & 0 & 1 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 1 & 0 & 1 & 0 & 0 & 0 & 0\\ - 0 & 1 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 1 & 0 & 1 & 1 & 0 & 1 & 0 & 1 & 0 & 1 & 0 & 0 & 0 & 1 & 0 & 1 & 0 & 0 & 0\\ - 1 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 1 & 0 & 1 & 0 & 0 & 1 & 0 & 1 & 0 & 1 & 0 & 1 & 0 & 0 & 0 & 1 & 0 & 1 & 0 & 0\\ - 0 & 1 & 1 & 0 & 0 & 0 & 1 & 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 1 & 0 & 1 & 0\\ - 1 & 0 & 0 & 1 & 0 & 0 & 0 & 1 & 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 1 & 0 & 1 - \end{bmatrix}. -\end{equation*} - -The Tanner graph of the first 8 BNs is shown in Figure \ref{fig:tannergraph}. - -\begin{figure}[ht] - \label{fig:tannergraph} - \centering - \def\ww{0.3cm} - \def\hh{0.3cm} - \tikzstyle{cnode}=[fill=white,rectangle,draw=black,thick,inner sep=2pt, minimum height=\hh,minimum width=\ww, rounded corners=1pt,text width=\ww] - \tikzstyle{vnode}=[fill=white,circle,draw=black,thick,inner sep=2pt, minimum height=\hh,minimum width=\ww, rounded corners=1pt,text width=\ww] - \tikzstyle{connector}=[<->,>=latex',semithick] - - \begin{tikzpicture} - \tikzstyle{every node}=[node distance=1.5cm,text centered] - % Check nodes - \node[cnode, label=above:$v_0$] (v0) {}; - \node[cnode, label=above:$v_1$, right of=v0] (v1) {}; - \node[cnode, label=above:$v_2$, right of=v1] (v2) {}; - % Variable nodes - \node[vnode, label=below:$c_3$, below of=v1, node distance=1.5cm] (c3) {}; - \node[vnode, label=below:$c_2$, left of=c3, node distance=1.5cm] (c2) {}; - \node[vnode, label=below:$c_1$, left of=c2, node distance=1.5cm] (c1) {}; - \node[vnode, label=below:$c_0$, left of=c1, node distance=1.5cm] (c0) {}; - \node[vnode, label=below:$c_4$, right of=c3, node distance=1.5cm] (c4) {}; - \node[vnode, label=below:$c_5$, right of=c4, node distance=1.5cm] (c5) {}; - \node[vnode, label=below:$c_6$, right of=c5, node distance=1.5cm] (c6) {}; - - % Draw edges - \draw (c0) edge[connector] (v1); - \draw (c1) edge[connector] (v0); - \draw (c1) edge[connector] (v2); - \draw (c2) edge[connector] (v1); - \draw (c3) edge[connector] (v0); - \draw (c4) edge[connector] (v0); - \draw (c4) edge[connector] (v2); - \draw (c5) edge[connector] (v1); - \draw (c6) edge[connector] (v0); - \draw (c6) edge[connector] (v2); - - \end{tikzpicture} - - \caption{Tanner graph for first 7 bits nodes and 3 check nodes from \eqref{eq:39}.} -\end{figure} - -The message passing algorithm is an iterative algorithm where probabilities of the bits (being either 0 or 1) are exchanged between the BNs and CNs. After sufficient iterations, the probabilities will have either converged to either 0 or 1 and the parity check equations will be satisfied, at this point, the codeword has been decoded correctly. - -\newpage -\section{LDPC Decoder Implementation} -\label{sec:ldpc-implementation} - -The implementation on a general purpose processor (GPP) has to take advantage of potential instruction extension of the processor architecture. We focus on the Intel x86 instruction set architecture (ISA) and its advanced vector extension (AVX). In particular, we utilize AVX2 with its 256-bit single instruction multiple data (SIMD) format. In order to utilize AVX2 to speed up the processing at the CNs and BNs, the corresponding data has to be ordered/aligned in a specific way. The processing flow of the LDPC decoder is depicted in \ref{fig:ldpc_decoder_flow}. - -\begin{figure}[ht] - \label{fig:ldpc_decoder_flow} - \centering - \def\ww{0.3cm} - \def\hh{0.3cm} - \tikzstyle{func}=[,draw=none] - \tikzstyle{connector}=[->,>=latex',semithick] - - \begin{tikzpicture} - \tikzstyle{every node}=[node distance=2.5cm,text centered] - % Check nodes - % First iteration - \node[func] (llr2llrProcBuf) {\texttt{llr2llrProcBuf}}; - \node[func, above of=llr2llrProcBuf] (llr2CnProcBuf) {\texttt{llr2CnProcBuf}}; - \node[func, above right of=llr2CnProcBuf] (cnProc1) {\texttt{cnProc}}; - \node[func, below right of=cnProc1] (cn2bnProcBuf1) {\texttt{cn2bnProcBuf}}; - \node[func, below of=cn2bnProcBuf1] (bnProcPc1) {\texttt{bnProcPc}}; - - % Iterations - \node[func, right of=cnProc1, node distance=7cm] (cnProc) {\texttt{cnProc}}; - \node[func, below right of=cnProc] (cn2bnProcBuf) {\texttt{cn2bnProcBuf}}; - \node[func, below of=cn2bnProcBuf] (bnProcPc) {\texttt{bnProcPc}}; - \node[func, below left of=cnProc] (bn2cnProcBuf) {\texttt{bn2cnProcBuf}}; - \node[func, below of=bn2cnProcBuf] (bnProc) {\texttt{bnProc}}; - - % Post processing - \node[func, below of=bnProcPc] (llrRes2llrOut) {\texttt{llrRes2llrOut}}; - \node[func, below of=llrRes2llrOut, node distance=1cm] (llr2bit) {\texttt{llr2bit}}; - - % Draw edges - \draw (llr2llrProcBuf) edge[connector] (llr2CnProcBuf); - \draw (llr2CnProcBuf) edge[connector] (cnProc1); - \draw (cnProc1) edge[connector] (cn2bnProcBuf1); - \draw (cn2bnProcBuf1) edge[connector] (bnProcPc1); - - \draw (bnProcPc) edge[connector] (bnProc); - \draw (bnProc) edge[connector] (bn2cnProcBuf); - \draw (bn2cnProcBuf) edge[connector] node[above left] {\texttt{cnProcPc}} (cnProc); - \draw (cnProc) edge[connector] (cn2bnProcBuf); - \draw (cn2bnProcBuf) edge[connector] (bnProcPc); - - \draw (bnProcPc1) edge[connector] (bnProc); - - \draw (bnProcPc) edge[connector] node[left] {iterations done} (llrRes2llrOut); - \draw (llrRes2llrOut) edge[connector] (llr2bit); - - % Boxes - \node[inner sep=0pt,above right of=cn2bnProcBuf1, node distance = 2.5cm] (ref) {}; - - \draw[fill=black,opacity=.2, rounded corners] (llr2llrProcBuf.south west) rectangle ($(ref) + (-.5cm,.5cm)$); - \draw[fill=black,opacity=.2, rounded corners] ($(ref) + (.5cm,.5cm)$) rectangle ($(bnProcPc.south east) + (.4cm,0)$); - - \node[func, above of=cnProc1, node distance=.8cm] (iter1) {\textbf{First Iteration}}; - \node[func, above of=cnProc , node distance=.8cm] (iterX) {\textbf{Subsequent Iterations}}; - - \end{tikzpicture} - - \caption{LDPC Decoder processing flow.} -\end{figure} - -The functions involved are described in more detail in Table \ref{tab:sum_func}. - -\begin{table}[ht] - \centering - \begin{tabular}{ll} - \toprule - \textbf{Function} & \textbf{Description} \\ - \midrule - \texttt{llr2llrProcBuf} & Copies input LLRs to LLR processing buffer \\ - \texttt{llr2CnProcBuf} & Copies input LLRs to CN processing buffer \\ - \texttt{cnProc} & Performs CN signal processing \\ - \texttt{cnProcPc} & Performs parity check \\ - \texttt{cn2bnProcBuf} & Copies the CN results to the BN processing buffer \\ - \texttt{bnProcPc} & Performs BN processing for parity check and/or hard-decision \\ - \texttt{bnProc} & Utilizes the results of \texttt{bnProcPc} to compute LLRs for CN processing \\ - \texttt{bn2cnProcBuf} & Copies the BN results to the CN processing buffer \\ - \texttt{llrRes2llrOut} & Copies the results of \texttt{bnProcPc} to output LLRs \\ - \texttt{llr2bit} & Performs hard-decision on the output LLRs \\ - \bottomrule - \end{tabular} - \caption{Summary of the LDPC decoder functions.} - \label{tab:sum_func} -\end{table} - -The input LLRs are assumed to be 8-bit and aligned on 32 bytes. CN processing is carried out in 8-bit whereas BN processing is done in 16 bit. Subsequently, the processing tasks at the CNs and BNs are explained in more detail. - -\newpage -\subsection{Check Node Processing} -\label{sec:check-node-proc} - -Denote $q_{ij}$ the value from BN $j$ to CN $i$ and let $\Bcal_i$ be the set of connected BNs to the $i$th CN. Then, using the min-sum approximation, CN $i$ has to carry out the following operation for each connected BN. -\begin{equation} - \label{eq:40} - r_{ji} = \prod_{j'\in\Bcal_i\setminus j}\sgn q_{ij'}\min_{j'\in\Bcal_i\setminus j} |q_{ij'}| -\end{equation} -where $r_{ji}$ is the value returned to BN $j$ from CN $i$. There are $\Mb = \{46,42\}$ CNs in BG 1 and BG 2, respectively. Each of these CNs is connected to only a small number of BNs. The number of connected BNs to CN $i$ is $|\Bcal_i|$. In BG1 and BG2, $|\Bcal_i|=\{3,4,5,6,7,8,9,10,19\}$ and $|\Bcal_i|=\{3,4,5,6,8,10\}$, respectively. The following tables show the number of CNs $M_{|\Bcal_i|}$ that are connected to the same number of BNs. - -\begin{table}[ht] - \centering - \begin{tabular}{llllllllll} - \toprule - $|\Bcal_i|$ & 3 & 4 & 5 & 6 & 7 & 8 & 9 & 10 & 19 \\ - \midrule - $M_{|\Bcal_i|}^\mathrm{BG1}$ & 1 & 5 &18 & 8 & 5 & 2 & 2 & 1 & 4 \\ - $M_{|\Bcal_i|}^\mathrm{BG2}$ & 6 & 20 & 9 & 3 & 0 & 2 & 0 & 2 & 0 \\ - \bottomrule - \end{tabular} - \caption{Ceck node groups for BG1 and BG2.} - \label{tab:checkNodeGroups} -\end{table} - -It can be observed that each CN is at least connected to 3 BNs and there are 9 groups and 5 groups in BG1 and BG2, respectively. Denote the set of CN groups as $\Gcal$ and $M_k$ the number of CNs in group $k\in\Gcal$, e.g. for BG2 $M_4=20\Zc$. Each CN group will be processed separately. The CN processing buffer $p_C^k$ of group $k$ is defined as -\begin{equation} - \label{eq:44} - p_C^k = \{\underbrace{q_{11}q_{21}\dots q_{M_k 1}}_{\text 1. BN},\underbrace{q_{12}q_{22}\dots q_{M_k 2}}_{\text 2. BN},\dots,\underbrace{q_{12}q_{22}\dots q_{M_k k}}_{\text last BN}\} -\end{equation} -Hence, $|p_C^k| = kM_k$, e.g, $\Zc=128$, $|p_C^4| = 4\cdot 20\cdot 128 = 10240$. - -\begin{lstlisting}[frame=single,caption={Example of CN processing for group 3 from \texttt{cnProc}.},label=code_cnproc] % Start your code-block - - const uint8_t lut_idxCnProcG3[3][2] = {{72,144}, {0,144}, {0,72}}; - - // ===================================================================== - // Process group with 3 BNs - - // Number of groups of 32 CNs for parallel processing - M = (lut_numCnInCnGroups[0]*Z)>>5; - // Set the offset to each bit within a group in terms of 32 Byte - bitOffsetInGroup = (lut_numCnInCnGroups_BG2_R15[0]*NR_LDPC_ZMAX)>>5; - - // Set pointers to start of group 3 - p_cnProcBuf = (__m256i*) &cnProcBuf [lut_startAddrCnGroups[0]]; - p_cnProcBufRes = (__m256i*) &cnProcBufRes[lut_startAddrCnGroups[0]]; - - // Loop over every BN - for (j=0; j<3; j++) - { - // Set of results pointer to correct BN address - p_cnProcBufResBit = p_cnProcBufRes + (j*bitOffsetInGroup); - - // Loop over CNs - for (i=0; i>5; - - // Set the offset to each CN within a group in terms of 16 Byte - cnOffsetInGroup = (lut_numBnInBnGroups[2]*NR_LDPC_ZMAX)>>4; - - // Set pointers to start of group 3 - p_bnProcBuf = (__m128i*) &bnProcBuf [lut_startAddrBnGroups [idxBnGroup]]; - p_llrProcBuf = (__m128i*) &llrProcBuf [lut_startAddrBnGroupsLlr[idxBnGroup]]; - p_llrRes = (__m256i*) &llrRes [lut_startAddrBnGroupsLlr[idxBnGroup]]; - - // Loop over BNs - for (i=0,j=0; ij5lGg(%yQmfUKMl)q$o~~UpG}Q@v5KkxPoxLAj&Xj%={3ywUPmb8 ze`AX4NlaP(Pi{p!WX#k1fvxg?1~Yc$|FTjG4h8Fv68oMc|F>dE*ZzGj{w}Dk{J#}R zI}yu8KjM}Di(9Fox%}UXz5dfp^8ZHoeixAUVo_86KZmTm4!K!Po%A}gDzSCM)Mq~e^S4mvp|tH? z*ypaI1z*5&`AjSFuSV+*j}Jo9S0E|N;qhef?@8VjN&Xkm_d@>Nv9tnNQvO#$(=Jfb zcP*9w2L5KzhUQNBUyb}PKuak9Cn6R7kx9eZ|m~E5xdnYRwz!Or8i?YzBRk9B>$H~i8E1IJZZg+s&Q%U|GPxAjkV3q%GQR;h>{C|m64`H7LiyvTZT}iF`ut_Y; zo+!!xqrg85pWe`-{C~rC^=>S`jCb-?*mpwyZ^Kvqwd0oMzgJ$!|L?Kl-U5$$<;wpD zlHK@%Z z6%D!a{}}TBFG>DCPi@uCr&b|9S0I^}C;8b5!~sy`RHQ28r;(m^F;ZK|&zq9`>}ryq z4M~2^tuCCqE0X+N%}UZg6S@fN*W0o4-ks!U3l^ye>GL(-<$N$(2hMkA-(}@O`t-`}UnBC<^B#F){u{8L zkZ-}__J{10{JYsn`K6@4Ht&jVIS|VIx_R+c_cktmF@uh4SPRNwLA+~0imI~8H_m~~ zU6-PYyJEI(S*92tX=aO<1kk~yu;6G%&~@ck*sM|n@qwvVXEK3H5gU2hzB<1W8?8T< zExv|@HzjOj-iP(dT!tKF*W#QJ>Kq@7p-+gQt}{{RpOM2dEzvq{sq@HMoHNXzywF-J zw4T(b*aAaos7)Z8ZE-vw^z5h($M^1*ch|XdjIgA|Ji~JQ>AIw`fh}{lyW{_8cgN+s zcitI`^MkOkIVaJg6gD?$;;csNj2QSXi1wbMbsg7G$fA;HtDTP-E@OnK^y&`o}9LAQmhsy z-wOHHZl!fe`By>;`FG|h_np&gu@rOpT#M_@=pyE&Vdqr-wOxb+YPT{+*v4#;Gs<|| zC*-Q5I<$<1RaCo(?*+N*O8Ix6uV)L%ecwzgmyDzwUkZV37JT`u1+b1q$*d`f@cb8$!JNJ>`zQU1r$a;=_HqEh~~%lXdBP<-Fm)3)I`NS;2`8TlVa9q#g90(Q#(eDL)ws=>?` zL;h!gfjgWRAz^bF+4du~Hu)*b{~RzJlt%DcYsMs*^!*q0|718F^1m89RwVgf)h10U z6S^?FEad+!lKd}b zR@aYG3;91D>Gb)SL&IaS#$5o1Ym@)um?Iq4B>(G^{GUMyU70y-f-2jY*{@IXzmvKf zY0V&7xRzRKlm9Vb;!{=mS5ACdx#!vES58PbKE?QiQ+M`&)5?F?#8QTKF6#fWv^C^^ zCeW_xxI@|f&vTIf>4e4+JC9!>|DNwQww+STNy`5kxV46oGps)cq7mjHH9g_*L4=Qi z+Xv&9<^NdhLGGGbR4$~Q&_FB{%Kw>AbO|&6mDF<~v>yS72g3p7{{&`MQ^}|NZ=|gk zz@J%gzZR$bn{yPjsFeRr%oe9Xo7X4#-$tEhGI!6ARptMD>ReSz@nCm9WvJILKt5+M zyZ%^`|C_Ox^k;^;3<-KqGxjwSGe0jiC<-(=!xu58^G^s zcBQ-zj$TN)Pf2QS2(y!2C8WV7FlT`X=;!17$vo{QnBu*m`RJ5Hnxp|K?81 z|3pghsW=;%p9wu0koIX!^54L{TvtE1r{2>54}d3AYLp-4|2W#J<#rJ~T%P3L9a3fa zKO@QidZhF~>K{aZKN@NsR}1;cSIGbA^!j7i<8yT@@_%)b|E);t2zYxN@_$~9_$&W6 zm*oE*Wa)k^Ko_z%_ z6260yUdsN8UFXwT@BB8XuKfQx`yFYkv95fXy;7Z({|CV8uUPL6%g@fAL;v5*KF9v- zD*CsQ{JVqs0Vw|fobH|1F8^mk$p*MtmY)qJ`8gg7+<4L&u=RxeTtrKbp(V=C<{IhW zlbpwat@3j#)KPxk08c)S6@3tP&P%BI4Eo@CaA6^KrDfRjKF~?|`6c-OlK#7vGlpm7 z6Z3Dt+mBS~Pvz(R*#7?sjvR~4aWVG8+VtnMV0IU_D(Umi)W0^M3+|w)pwBOIXrClELaaYp7yPA6vZeu`rNTNbz$ ze$jqQw=CnWJ;KF&Fxu}7GUj<jH`YBT!}hx>Y+GGzc5bEXX-lV{=U=i2_>;UY#SZ-4>URD z4X#OdXCm6iv^F|ZE84G>&Ut}0Ds61eccabjh0!WyJDsI!DX{&;=*hRkJY&}Ok08a< zp55nAZoeyrj>(`f(k zXvd?Q+J7QiZ4=L3+kYs$xPX#YK!L_4{@ebYP3=FE`VXT02k{P(uH1f4I2i_J{djtK z(urfL;D5RO^JxEU+B3JR{fohTA%DlC<7U8r-^X-pr?dSB(*9Fv|61CAL~8%Z;d~UR9F+N6^@tcs7q<6lnXu!Sm<+ zj4c~WYgKi$^&eCFuVXzZM`zy7i0U4G<@V188&8Ju4Pe`UAk8N!QJ-1iuS*jafI%J&D#Gd+J7}On0ND(*VX6CSgjfkzJv17 ztlIo9?-AJkTT1f(Bjo>Tp6dV28r@;}`g~gcA)Za^$oqJLcUQqSYCVko0~aLxkB1U( zpv49M#D5F-J)oTUe}=Z*%*x-+1TX%RbMc>;AHrVcFSA0`JDU@$_zNAcF7C*M{jh8+SGx$Uj#O`U7=$eLEe8LBlWL~&D1%IGxS&)#&*E7v|9zVIlqjCkZ2%MP>VxzaTc7M& z1{{w_i`ezpHmoVZf9-2ArV-lRrNRG>ZM2pAj~!$_KYhBpBds(1?~jgjZ<=$Y;D6uJ z7@)ltxTDSS#c=dd@L&Dzm_z<|Y(tV_%AjK>*NS3%5j)gtv9P<#H25Do_go2*7miZc zKhPfPDXrkYVvr&eI9j=5cxmtG#P>lLLb>@o59R+1dbxpVI}^bOs$7x?zEKurnK)0{vVk5zXbkoEb;#!b~LSNADC44L9 zBY9KoO!jpJ|F4BAo=?y*|6hZx@hEH;cd+m8e5@fKgYNHQ47&~fUzPS|7>PA2dDn;Tk`8VtpBRS|C4z;(*A!X{J)LS@2jw~zPTp;-wFR; zOTDjVM^c&pk6<6Xn3ankc3A&f<|?;f5&B34{~u(=a9iU4H#>x%ng{=n&Zp#+{2!CE zGc7+c@2G%f%nE}37pGl|yDI2^5^~j%I~7Y@(Elo0v8P1;OOWc?=szL>_O6AqqV5o*&^Sgi}T`Ie*zblFk8{Qd~H>QeXO)?O}a+0=Qb-TKk>vIKC{b zebp$$-U~;c+8~`(RXfKhj+1>~%l0>Kf&1V+Z!y~MsgKppr-d^fN87eP?#p?mr}2yY zkM=j$ptj##!L!p`e^M*$cN{YdEo%EGFb-_)%I()4*?fc@r|UZUvi*bGX#aTHKMu`X z-{J{9f#*S2p1ZzvR0oz5npMA)d-rdT;>m0Ky{~j9qqT?e6q`@`T?<`ZnMinbsr?&x zT5iVP)SUkZ^9&z~PO<&$mu=Dh0bu9pfAZh?QCQ*1m3ShLBl&4r1Al{Cqb@!aDOR4h@oay0i}ueiwSOvHm;;|$w*MqXjnV$KJW-mr@69|TuBQFh zW68Ui@!=iK>W}vSfc@Cf{x3I6xBdUq)c#+!X#d%{{9n!*m;66~UEbAhN5cOkEMAkT z|J97Ss@+c3UG6F2{{Z-Zv^trc(Bl7ZoUgE*6_o#Ifq#_$ZOZ>3<^R4#`HS+R{O7VA zdCT&fRad%I)5c%%>`+hpEAER>#FukNeB>?C3Yc<<1$3koWjFVu6!Vr{xeP;EZ^Ac6 zJORtKsS8c_T8@qTvYzyr;-5K+-0_@=JY}rPp#n2ws-4fOup{_9EuLIHA);O(wHRpu zit^3pPiG!;h9yZqY*dB4(2~W``&bnToGc+=qa6WNU}?#P)A|-W4=u}b;urPC^U-H! zlwZcswm5e8NmEcso0rzdaN^(^g}>PS7ws~S&tG>q8e@*aQYp^WP8*iiD4lRV(~8lB zv0A-smvJ%Pkaoqqz1V##w3tS2G4$!6Cbd-Wicy0l3LR2Ve)B91-HPm)#rSe%P#k3d&rNzcyP=G+X)30={ z%t>YU+R6)Ui$WMj$>jJ^XY?%G_$UWz)F5#QK>9sIOJ+hq=EZ42B{ z9HTK;_H3`zkMWVzjuym~#3mQIK)zW{XasZFLVsRER>a0Ua=|$NLeofx;%98=fyh_x zJ<&&_mU8(~UcuRx_$m3uMh}S6^0U@F{ zL~T)ONNcp045>E#va>{`$TF0?=z+1WTu83#-daz!T}EBXtj^vN_Ed3=9vt>o`;TQu zzbf>fvBBBkXq2OL1m)sNmL}&I(l;XHiJC>JaXr+qeOj#JYZ*ZgaaOLxS9_gn_tq8j z9_gz+Mmeu)t*f4>)PKHD zTh@P`d+qt%v9rHY|Mj6pDQ_zaJydYECH?H3h5nNs_SF8ssV_XcpwNHOTctz1p)9A| zf$RJ0q5nLEJKlL$TI|8n&^T8o%sG@hPX+f~lvvkxB|JFN7Js!&SL;9bZ-@T#OTMB1 z;vE6s8rHd^I`p6S;v4PhTe1iF#=l%E>%W*qiJ!X5w*hQ}a~&zyFJVcr6&Gin_W*Jf zob#M=saDp1p7}6}R=YcSG^u_u#8VXd6RXDY>#QTV5B)ccc%Q58jyEOtI=Dl_Q)A2e z&r`CMDo>BdlFhm;`W5;wcC4to)FAeX_<4;dxe^^cGW1O79%b7Vmf~lRj-IPlQXUOzoCxBZ3ThyqYx2W-#8=6)XNi&DzOa9|AEzz;jwVI@=Pr1AS?E9Cv~aI{ zoCBjq@Vg=Ii}%eMtp|nvQ?gw7aOY1y@(e~o?O*X$h~F#r8y@1Qyjp_P_GIzFNTgrr z5ML>vi)#v&F1~Z1^tdbE-7PWxvxjy~u<8NVkJNs?Nimjdq5noxQ?xv6+}ii$o~@|X zf3ABeZE=c4q5nJ~UpW%GE&RqYM^|#jkylJ7QR5WCoq}@TllHXJjKWH z(iG~nw+|)1uB`tSq3CU5{IcpRv9$iL0mms28Qcbfd{#ssF~a zFRIXgQ&W0tm;TIy9plZzB2nnSIcZ1L4BF|Jzk86vevhmHn@BgT7w*?_?!TOvLjO%B zm!+ux?Y9W=}5_BAUp-ebFb%c*PXJ&n9~c}q@V9ND&fkkeKDSiz84qg ziK|=G9e!ELKIs1Z(0`6B{5p^M)YqW{T^(|T$=(|J&wc(rh2y<Oc3(xqdc*yAjkR&fQXv@eCTRVA|_^ zn@iUczh(5TX+RG^BK!umBla03`Pn)Jt(6T-_Ovs#P4v*no0hpz^eadLwhyd zOeFeXT2`t54q)AOELOWZ@OKa4N-&(AXk6&O6_jMpo(#Vo|9R)wrCR?9ou?i-gHqIg zliS2^9Q&^p(pJB?W6$#&4^s%chrX=;7LiN+cRUuY(0@k*bucC8K#XJ8-7(~t#v2QM zuUY-Kgc8($ClNP=6~^gcqW(L9xMQH4-|P8X_203S72|-8^xsM3b3MAyf2VO@)_xSmqvTCCqCJ0;!8TpSih9dy|Xdi4E^U0RP~>u z1@)iS`1n3o7jn9bqCaq>iTBA9;|D3&vVROFpE^Om7xLkV!l%&$ex3)WhEf0dzMT5c zuQ`dMz0UXAD)paFU|VMk)PH_AsZ#%Gt)C2h@K*gdjr8{Q-%<2Jznc4|2X$kxY{WlXSSO2-6Wf^_xNXqC+8O{TIe`gtYeg$e4cjH(wKA4tP>%Ze@ z=fU)(6X3Y|Z*`mey@Z_WvGS|`&Z0k_3nuEnv(QPapu^E%y_z)j-_g`2H`bH;9OOy; zcOejmg2_-~jzHr4zR7VV{kH{~JOaKShpdfdE%Q`LIF-^pLFz&z^%BZEkrL1BK>uAz z`DOig0u)gH?ZA@1E%mkYDZ4AN2e59f{`1>3o|vuv+l3We4b}*4yD);-N$6-Oat2&J zCG9a)|D8vhx{xxIUmv~>;8!JHOAmWBrHJ3QHtF{oTDOp1_L`*s&gIRD4N3pq!MggD zP-8s3^b&Rs-vhp9u*3CmVs}H`(0>@kiI)vnK*|Q9ERVMy}>7f z&r!haVcldJxqFiLt@P|Gq5c(M>(ls(Ht}=(cP-Q@kN@64EA1VgR{ma$&_B7LfYiWn?M_z^gdn>YWBfFW-p%)y>&Wx_?kGY6_-b?5sjjR{WMv_mWjgJ2| zp<~p4H_@x!mo&g8=rPcUC4PtKW)-~ zceY8tZzJt>oP)HFK5;K=qMrfkS@g)GJPg%;Kg#anZM@KbUrGA!EA0CDB71r&_1_1; zvs(W>&mOH`qW^9|-(;Ltv>u$Fq2150pUXG1)PG-ss`Z3_-H!g7njgnk0n~p#Lq0

z@RPs{?f$Xe^31V zIn;gx{=Tn@zwe^|{sjJBllc2fr0|#QEqpNT0(ds@_j8HAe@gtlnO^lIwEY=7xQ5f` ze?}`GqmTbb;_u76bMjL5@8J61@TMdFF3OK3|Bzh${Fjn`Zlp1<&Ko!xZZL1u+(J+G z9J*t2`Fn7F47<;;ZR7=ir{yczNjES%HNT2=|IPUipzA5nRsMbl{+GfjBUHq<@7E=mxC&p`i`$1PrwSQRVLR@^ zopzB|;vD6Kt=~{>PJ3jm$Z18@e(YLMP^-2QT+0?;?cH4n*Qao8u#Tbv>tg*W?Ah9D zYIU|a)^xSn#Tz(5)mlp^^2I&?@u{7D+V5k<%QZ1e&>kiYYIEA{T!obju7U^sYj3}> zTFSId#e23=K+9Qe&b4c;=&?o@)_&J;YIkx_INuyl1{|wtSE$YTzNu^5+TFGJ1s=7x zUx{}Nr(Il5*b>(jUx|}@t~_;y|E@y}p-yX+|IW4jifFAaR^vRIN2{l&>Us)&?d{i6 z;M>K$dG5In+!deB@ZS@F{Ayz*|Jz%yYu+yHx~@cMgAD#_wP?QUu{l)vejISVgW>v| zHWjU<@xF06PkSNXwedX{&rkNGb!|1;WnPK19iBYpY2URv-xZz-^~N&tajjzjA-^+R zs~f^N%hjST%moVmyBbofo68)(52Ksl|5QpD%{*pGt>BDQwFi0PyDKbH;ih|HYw!PM z{!dKyrkv5`T;_STx^c|GDYKaqYjn~|hnEu70(tX6j}GZ6WI5p#-H#{b>$ ze-ESWjf_}>|2O z`2Qog_a1Cs>VNHSwYjC)|G)X~NWDCBiTO)Vu855s#uf9L0!F_%L^-a=9XZOSB%n@Q zgmgS+dHxl%3uj8@+KR9RM=nF=DImQQx`;EqD6N1FKT0*dW9N*gn0Z;3_fbQ6KVsAq z`2wE^S7INq&VYmtyaL-O(-~5^Y;*tLI&rZb@n`w2FBunm?qaowi?FfK(Ej z;9?q*ubk-Roi}X7&a#h+gZQH+C)dA-7Zz_d;_>QLQ7k zE$A<9o|WRtUtGoBIN!OnHHK?-wp~flauMg4xeM6yx2#XD$_u&gz4|3uBChh+b9SYh zI~%2Q7h=RD^ozTxq@i)<&_-Zswd3c$DygCrx!WoFsCy1IhqUQXx2h5i#`cLap4F`xUp#7hpv zelhi5^h{|K`cFHA@~IujQ|080RB*SJGHCuTYZIm4*Iu zUtCz9+^=mreQ(rnr@6Dv?;xrZ3`x7e`0mlG)p;I>GVbYjv47Ux*zWyw7p*iMn($EW zq)zBR=O05zQ{n~_D(gS-D^92r7r(>k?p(3<i5h%i#YV3 zq0oPR(NAl~Aace2Uf;1*_t*}5a;5&WjGkZ9{%o1Ho?4yz4h#L~xp{u|OlzI*5s&2Fz1{9CbU(K8=Jy(X%fc^CdZMA{ zGy07MWi#|&SgA8$)heD@ZJTV1-*;1jmEBsMXZ4S#E-jy)I_-L@`^2q(B=>#?PW|V8 z>d=4kw^IN4uDU(5Qvdk|^hjD6)GGAfcxo``2uiEfb;GVR0W3oQ`5mrt#5BMODOJ{g zBgoZ{n2EGxe3kwakD&>s(0@{UBAihF4I#BV)+hDfQ1Ek)xTi<{Upr6UbSI!YT*uIw zNz|+5UR~$;j=tM687!uNP3XUg#7rP}ckogFO--~@=L}CgsSU%Kw9&TCpagew`^{3n z2&w+_)O^1y>6a9SLp5bg+VucJ8FDwjkVAlyhrZ|H_b9tkk|$iwz%TUQSg>@zoceDn zCDiJ~Xc{%lM5f$H=qZ`Qpu|w>84IrNG*|zPBG%K={Vru+u$)S})PIwp(R6ZjC#U+) z?*Q~BZZ7hurkh8fut(X`+_OA4#n!I>W?`W&^xt%_b9@o{Zw9jBZzMdMggp8+x31JT zguBpx?$(pjW&I}?hEZaC*V5DG-8(rKyoXbY`fm~tozZ^{K+L6HcP_~x&#Ih{C9gk} zm;`oHsLNC5{f_4X`c3FR_wzN7SN%7E{Ry7_)tCHp_?yoCQqtT{TIj!}#Pww_&}izK z3C5k#f4*0sL`=gn=hrLMe+MRY51e3jH^S_P7(;e(JvJ zKI9t*N7a9e;K=~&t#c`N8P_@R$2SUUb&KHUN=hl~zq!=C5S#~tuljEuMTP!z2b$ll znE}?bsM}LCl+@|8&$B9w=}y>lcozb#{&N?*akI#|68Ur2^zu%uPt3#`K7kd5LjSF% z-?f-q5qD9TJFv7#wvvR?|AOVfm>ff zG5$M%+{0c}|ymPG>{mLjTP}+Kwki{dW|QGsu4! zSabur8#{uILN?TYD=2e1`;HFgZz)tfnq4oU|JKo}T3sV0O{3&9=?lkFQZFz*f|Axi zmE*wmWY$-@!?mM{J%^U7|NIi_snoCjbASHn&|?|$75Z;EzTZ|nh#ZGw5no073jKF9 zJH(7Vs8;lljm_}v2r%i!POM(gCiLHdV6!Csj$^gwG&I9eVA++`oX~%VQO`PRSwouN z4_HHPVM70T`o>~PQ~#X~t_LCyXVBhb$i0T^%9`;z9i5>5TaDk1RT%Z(g{&tW2}jOK z`i~tt&`JHbmAcCM?{rpv)PHAy*-BP#)=zot0cYt7Hu{K8d>2 zf9~$A&5fmp75eWoRyXQ_4gI$Y`3e1ZJQ#%j+X&7l^DaVP_*B+^TiGk7{*#*r(TYa; z{+YBz{dY;yf4f+}QvY2<>KgKFuMIhJ75eXNC_f4b98L?*WBshG|1Kd{4mHlDu6gu? zA=EJw9D746^`E_9D)F=7+h*v#1^stQN&l?_lhA*!B4?rhE{6`ay3l_&Ai?g*KMOvO zqm>QpK~?{`@A|dSA@twtvJIq-VUOG~tVhj6p3Wd`BzugnLV_ERQ1##G>_XekuCf{Q z@)P0C=92!q6zO#QcQY;czt?})qyJtF27}n|`HqtQyAoQSPF?SXGUuRe9RIx+KFp^V zoyvOFh3LOKx!=wX@X&wj$o&>}<91H}y$%Z8M+v)G-`WlqtJoj875-fbK0A6w0EbX(GYd!f_q;G+I}55JSxZy5UTZIn5kU5^LzU4xtHD<5Dt_f_Dxm44qD z{r8%r{~k^H@4fKvQ%V2bL+OS7yMWcfYW;UV^m#Y(*n{1<4|2lyZTww}OgjF%y`=x% zLypjYABNsc3Yb-`gqUi}1?dL#%dw4*lmY zegk^sb=36!^evD3NV}K6`^YJbdtDbGVK-9JrA_+pZrbq#CH)h*@8f!Jt=)sYh_}*X z-C-U2&sIOvLjPT!^q)Hy2OvK~kocuY-glDz`!c&v???YVRMLO9C;j&xD0~zB<2q#X z3EErMe|L0J|2+UjrXqXOX#4L<`tP5>`O|2LPtZ&6r5`SV9v^{fKVUWZWcIO!{<{TA z*CCHTYtnz;XaDTa(0}jcoc2QhT}_+Re>c$z_1|a7^Q)Ta_fN>K<3Ha|DC@sJAWgR- zDL2v|{++U}VlTP+?|xReL;wATeZ1svPPu}_^`tMg@{ay6mBgo>nXmJl(@FCuK zQ2*VL#(#g;e=+|1yZ+0N<^Q+!pX&(4pW}e|vwP*Kk9mzyrEjjp`H7t~C%~7}O5Z3K|tN7#Wu*0^K!*VVjer*#y6hOOULwC=QfneKX3tgVT;>sOXx zOyF(l#@Z@Z;eu+hW@!m+xq|lku1ILZv}|j1jnkDJS8HPZp`d?QI;|z>-!^@;m|C8z zqOs~BJ>;LzrdqOVE}n8zv{bweYirY%-I*0ZbGvTfik5iU9$OODTh|YyWwc1kmE+&G z@ei6>zxddK_-1rSg(W$bihbFEtE-FJ+g(4A?y*iwpjFqE(NM9fErvR2;Tc?7=JowK zmk@VXM_rlo=c-0fs_pTdly`T6rHZTVkr!Iul_=%KFH;Atv=VDOcD+r0C=a$r_|{#> zr>mGDpRrfl6)IQM3iI$*rakk*6Ea*$Q~tH7xaz4? zmF3?RJomJ>?mW3)sgE^h&$Ctj{i>B~Ag)GwqO5CiQpB|q<;AaCxKiYrgEh9@e+&5^ z44(Zc%hhAQVC)GoJsE$;$vU2A<6274tdM`dg)x8>PsnP^x#AV)ZnT6ZD;u8aDO zE7w}wEwB9h#j!Dz=ZWZWC?_0&SyO93|Fq=jxTDy8Pw)aesfy@@hQnvE1#EycB zuAa6p|DJTu^RF_{^)9GsQp-%~-RGXL()EXj8ZD&^mm(rLiBHr5yTww$eOfEs?i zO8M8y(1Ur4=QMdX%na)D8@}UchbOCq{+~#DdJ!A)KLv=k+_(hQ0AwNm;yIQYJ)>d{ z+#Se#*ArQ0QG{n2x%x4d8CMVLluna6l>b@SdM1O*eA>GZD8IFwQ=|6dZnQ=DUrKFS zWv4Qi4EdjxEPFRLK7_c)O0@0n~pu zHFX06-`8*5tt-j@S@dI&cA=Bo#NY2tj{)@yW2=>yMy&xlKgLie~Yk;cEzT*0t?Z_^zTJTOrihZ zn&khwHjBRyn6scuZzS-#B>y)f|MwI3Hf+Dj|9#N;<5lwS8#lwTcfAR_(mhxe-v)eJ zu2TN*M4m6lvUMRVId8=7@F1n^#U}L#^8fK9|8GvZXEAoU#l(MzvOALhM=5C%zk zTjBh5oCfh@+7t4BBU}&pf1oY$V11lQYv&`!AH}}=c6!?HutI*1w(N&G_pz?w`}$Aw zj?2BANq;}@r9Vaut4UqNTk0R+UHc!lEB{|@lK-#r?MCJQYvA_+^8YrZ^$p1Fi%I^! z)g=FS!Gr%y^8XWR`NQAk|Nm+E*ZSaJ%s0!vp<0~z!eV3z{uNdpLmfM3mQjCUAJU3t zY%S15`C%uDJ^axIXT6rxkuzTze{Dtu{?0=?cG?Hr=@>Klu)t}*iMf5p@LE`Gf8e22 z%-Ks}3F;U=_GQNm%<-2qZfBFu&T6Ni^~auHZ7r4-d;U7EKkS6oXnpQ<6(enJZO>^d zOVx@a*3M(Z!g|B@<;=HZ7uGK=H10|L*M;Z^yP;MYM7_kE_**tNiyX(DGk< zNX%V3DnZLq>?e*d1G(Q*{=28QmimMLe(zJugL_&F{yVbn*aiQGm-z4QS#1=at6UrZ zrI%m18J!@t+{Bka-7i}k|2=s-`0tlQ-6QKjyjKP$2aI$)=B6NHW;3vSP`OI$)tKk3P#5sqoWtWHich}R| z%ngJ8YvF-AVotA_{|6@iA5W`2eR52;3i&$(YIwF>NA4)3^nw!q51`L%Wf#VFB>zN4 z-fKDnCOt>fo{FqALIL@I8hCe2er^2sJS_L&Zi4oQRq+1;_`j=$`rYldk#+vlSfzL8 z)g)#_p6hlb9KcXW#XcQAj7{(k}cNIJv+t4jQTl-*F9 z=>PJ63;h2ybBm7M_4NL`oA|#Em}{BqysBpYKf)<%7cd{Q|9fu0R%S&%VOP-q$KHE@ zOHpNSzZJSq=5WYKr4d9V9&(l@gCYVVW=|6pML?36+nf=MjIm9K8FNByb3(;1=5TZj z=s1dwc@*#au3gn#tEwCP=KtOAKF__kp-xq;-`;EOwZq!Gs;j#n$8R^@yKVC*^I2Z| zKZGYhZk6^w4*ORy{`uW#+j@P0+BymC|0$l=cmg$lF1~q;@&6E99sd9AzpdKyuQ~GR zY#f^F314Q;C^uIsnv?ohDqJr|^D`f3a)09*(`X~{wQ>DM{k&%2ob10S;Xkg6`93bS z7#k)9tsBbqv$^KrJ9++#D`~z1%XPh3+xyo`ehTiXmCucH<4QQ6pKEe+J!L+3Yu-`I zbFR8M-*O$s^6?Xi!SYk5S!3}%P`|G7`MKKSXOOsp=;JbBP;qpC1-pA(q zpj@B&8mN>0Q;Yco8Q)LzDN9cOc^95{+<0wM$bY^+$M?nx`_FeS`Q8CnC47G_sNeX{ z_mB9QpK7dK_}QVneLnBY-=XLCOtGwdqAQr6pEhib6wJq8Sqb~!3ORiLxwdQpfB5Mk z-vZxPqhl$AJ{qKuAYE@VRv<4Z9$RE`2`_KE)?J+O&JKX!{a-@7|Hnb&e9!;U;B~l@7#xAE@Z@JD z=9RJNeZKz-mH(4*uWS))`u;D(9cI6F*#GNLFNdLy4ut>naUXgC?wjVh@&90GoQaM7 ze_lYlg*&@5Fek2sXNN-<{a=9@FQ5N*_&*)?*Ps;q#^|v)zBRzl$6fCxm|@q!{~N6P zagXs-)js3!yy|>Bk<90=@5R%fVgFab|5KFzm*d`Zu>Fny8$ACX!TrRS0`~u(_TR55 z?#;0;f#5H_{G7bYWOSG)`q%WBS%vqc%zY{UFXx)S@-p{ln9^7`_tkhDp2rGn zHKR0-7=JlWnHjHeuDsOT*Wi2O^uRoY#oRn&3H(~k=g>!-D>yIlo|JhigVuRx$IPWV zb@YtoH<-EjuiT^J%xh+4de0e*dzOkb)3)z0@hKZ~kAt%Z)0_F#Jgc_t z{HFeCkMkfc^WFfTd7>}d&d+C~cz=PV<=n)3gr*iaSF>%m{^Goyf3}BL*8JuLKEGt{ zmTkNJ_*s9pKku@!#(2Mv-$B4THGFM-9GEA3IA`#O z`NR~z34y<;wXGMQ*x@%HnDN8*r&YdRNFCd*e|~sYk#h|I$-`}`*%f6 zwnZ&=fiJtjdlx#l_2O^uw85H+?cWRSzdh!0)Bf%MQv361l&;eL9k4g;pTLTbPh_-3 zyKbxfn&bI}ez>RRV)fDnCE)L(oA&R5l5D&EcSeo#9sZ$cy`iWJu7tOPMn1pvS3U*E zr(gJq6}JC~T>JOLy`2G4AKR+Gfw10H%E|U0;kExj9QVb#vir8OqqKc-ABNxmK22J^ zKO}7by|C|wZCfwX{(HiUMpyxkllDIVzU(LMzyG$fqn7gRKL_nU8S6yT{`+9fS^T*W zUvXbNjS+7DeX-*E>+OG(wEr-y4BH@IO4@%@o4|!@y`DYc)<2g z!L#H1LT+W>1WybcjJq_4dhI_I{>(ss7;UA|{(EjEr$J|-{rQxKg?myK-e2DrW5B|@ z>;G%*e>>X$c6fRs`V8BDKm0CBBiyH(3q4zZwZV5{cEJ1gwRmE{wEwaA<%eZ>51!-y zp{-{I)$P9k`Cjze|1o^dD6`G{eUXEon_G-hT!ETcjO{sT|0~cJPecB#x8DkU{^)ji zdw;I|ug3U)R@(o@ztH|SV#KY%`2PduTq(3@*P-JsnuX4uL(Ai8xZC|sAUFeg%Cmf~*m?x8XMG+*%D;Gi)P~pKUQ3GSs2e zC*`|i;|&D1!#&v0SEX+<%`r&JzKeEepJkf#cx=qWyle-yEA4pgj8uQ|WlP1NKHxvD z<>@u+$aP#BTX|K3>V`FqxI|a4^!>1PK5RaMEsNtPus<6ceYgO7mhD2w??l<|!UliI zL_QG5!@y8CQU|Q3OTgI2S#PYf<=AtqzlQB793xG73XcC5U((uejsD>U=ir^~mXuX& z{axJjMwH=kY;Pj#BiQ%B_7pbsao&6gI&4jm6;|D^Fnd|HKL`c`Pq<$Cbt zII&nsNolDY)odvR%)^vESxio3h+i88*L-mmtkjFFpD}p%=$1n$Q);c++HS zuUBCAb!=!iE9?1lWr4llp7fX8JCCY{aj_o9tE9x)mi-5j{#<4#e&t;CzLQeh9 zc${guAwTUg4a-3LQXb~dVng~!{sqW`^ghp}KN9*DVPjc5e^?&z2ew!q(a-XYK^iQL z#r|mQCwLoVfAxhv$T$MUGIS-VUP#%^~%1HaLCtCx^8e-epOWFhN z;@}_0l7xA-3Fh#ai^hoI<-|C09Y;nlq89$UG5jy0cmeD$1Y3mtV(jN)>x^Ue=Xuyy zc<1AB%nj#C_7`}e^kT!)mpcxe=VV3f1$pjxE9J|jDNtTA#Y=FGP5ec#PJ0_=MPD2* zG6`{xi^WSz;w5FJC1vI1rR5bBn1!nfR-b#Oh{r|BSeCEsB<@UaW@>p3V7o|;_ zw)B?e9d?pD!9VAr+?)q)!TwV0|AsyNrf*kZqhD*VXPjdF?t?w*RN^R(aeIYdX=m#5 zWb7FOC`TKl55fMgzhbhmW_rdNuk0K{oMZDh`+SEX!z+e6skyR5<4KT|k<9ot46zlJ^QW7{tqv*1==5;ImJ$qmqX z9rk{mC2@|pfw$w$Tke!I&M-b4i~V%$xB3#p+qBPnF4BKTVBZr8Io5)EjtwyN;tY>X zWS`>i7ue#cyAo_CO`k8j1HeH^wl3 z$hCJH>^orF0b4uhU|C@+xR>?YQpgSlGcS}D^PYbe+%uk|ZgI=c=s}|NcGw!=yjgxP zHvRK*lRlkS2=!Rp_;mv8ztW%Kh}T!Fi&L?&URXc(L-zyNrr>xg_H29f0VxaG1YdY& z*5WT=kA5Jr4&#t7y^<|ZX(pNZi+L)Y!6EAkeo4J`z_C|vQg=zn=R(HzfjrG~)+zRK zPlM;3v8Ax#Mf=?3k~Uul28RA}tuMZ#?r>99>Q&0YGIWBBb;@#i=d5?Bf3j}aSPr%a z?XceQGPZdIiWPs%zi(n#_%G(xnV7TpL2Mdk?T%iEFV@80$=LQm-yDr?GR6|WRB@m5 z0q}T4q_>MoE^X!V0w4Q<-zbD9*3EUV7A(zo5sPvuHc~ z%m%I^avNpRqF#DlF39My!*h@gqjpJyvRFx3i$*OgdJf(-IZ`tDe4;eN~@gGlIn8Ttto9#Q5tK~xIy#k%7#@9D@w~7mp5u$-LP4!maSSgYt+1PRg=c8 zns@EiqqbM?K7IT3A24vxkfFndkMIl_y||>TuCm>@TUuGuptQUu*0gD(#$}aFD_b;g z)}*3&v*ztP?%ZjY&RsZ*=@%;v;j+q(#VTN&`OC^0pa9j4o3+|Lv14S(gnnIBRa4Wf zS@Y&CxcV)zD=N4)Z`7!9vWjx7 z`zy;UtEw>jS2t+Tuwiv|O-;j^#*G>^YSIMOnl)+KtU3O-Xo>%=TG5QSQ{lu*VhtK3 za2s})9@{W(axYZeasZg zUS4CjsVXg7X_wYe&M=sS9)?=~RXDww0-1gi?5|_u>Y6dtEq7~Jc~n{28rFJn=iVK5 zq?l<&Vfzqz@12kwZp4Bji^o_9nz1e<~Pci zTZ}cR4~KgGU;0XwCdIR)xA)y-)$--SYmzCS-=>>AvEOe?z4I2{J{wEQkuP8Co%`kX?RitZ+=^m`Eq@w+mV4>{ z^v?bI-0Yq2?{P8mf8b9iul~cPKKI)7CvRU;l9VLPy?sY--_P5R@%Gca{Ty$<%-e_c zj~zL3P@>b`GnUR@vNX}Rd!O#L-TEz+vz{mP?AN`vPxqd^b}=B)tF~vq+J3eCS`{qX zM3brR)4fhAfgx-G=O+C|^bM1KaOb3?l0Z=){RX6riM-7IvjkrywYQh3kRj(Mw4Kvo z0Ftp5ud@-kW2fxF!)JJSDi4u)3wH6c zlCo9ibf~C|J%%JDWnV#7O5i*K-SOJra9H*r4&N^M?kMOl-xDP+`F;$^7t1X*OYfd^_2X|4}VKq z+Am^vW(DiAq@BGUyOk9UsCpOsWt^<8Xv&k$a+0Z7!8~2$WNk%flCE;HuA(PTy4!1z z=Yfikc+x}4maVvyMtjq^tpe%NSXK_F&n^L47`%--Ce%Ti|DP1lJzUSdo9G1?(pK81T zV%cTko^D?;9HnZwKM+&7t2Qich?&2PC2&_gx3ngXg4z{KhQ=k<15bAD9gXIMuaok4P*Il6I2 zmgNX%Z#hpNV^w{M^3!=~1w4VvR-yZHj?ZnDeG5SqYn~-GspK!dPm#?ph@}^yYZ6$c zClmdQT=YbQF_XY5z0yZ?N`!Hfz$$&fNAypGB_@GY`Z^JdL03gsY7$tb-}s1Li?GZj zuu97zkzA|*5tf?-R%r(!mXLKJ!p8C!-=#B*i2d#`AK_8i|KPmzuoEFEceCD_p>%&g zHf|`5*ODLT59yR_VgmC1qK+Bx)Mxx8t;?5qv6L^e-VT z71BIX~s^$XIhG>-F5hLf%$nFSgZ+y@hNF648E` zuN@!as$j~CPLz~Z_avLjD%~HaHT_90`J0f0B6PZR_1!{}igaV{D_;_lQsh#|O0WJx zNLmpNiqdOrtPINCOpr)lZ4SBA1j@P(?XKw}DYJe`K4l>(lYYultEN3`ckSMiGT9?Z zr>xRiKjmS5%9vGi4Qu!26D4KJPq{x+au8kQr-b!GsN=SqBxTx9d8(iCQ9mWDU(TAl z<8?`y^;6#Nr`+VHg!K>U(Vc%t%8h=?x0#aTv@sU1;(K$e<}G@3@6M2vyY+rb2d9#9 zh@TQaQn!{V@1HCwleI~@Zk2Y$Y0VQHmk%B;WT8)F1k=~FuLIUTV4n3COUjI&av@Ho zR&MrF!rD;keDpC%xzSH~nV<3vKPAS`5v-N$my&XmpYkcD+=4&c#Mib~X*XD};a%3! zCtG4ASngUqlMvzj8>Fh4Ne7?qB_yFp8#d;%6NDs#L`+PFTucnJYW|>(7nVuNw4ZV^ zPHWh$OE;_(l2zndmf+=^g;>3kERa>oJWVoa#%MF9kb+gY_mx9R;Fe->X-#C?ssfJZrqOJ0@v{txMsD9BwVUO z$fYXoIdG{OlQr@aVX+?7%972kxr$iDjpDNg}1W0N}oKu4Ol1W_Q)^C!mU`vJ(fGQjYUe9*5IP&Q7sK4-45>5zbDrC4U!ks3M%5V#~f2vOGw{ZVaUo zyZG@&&Q7tTTR~FpuJlv>K)alsV#oFtvQ81sPO;IXlHpStVq%BAlIKr`;mtCq+0r#m;zI$nQZScHf0uyuw%aaCVBF{jH=d8=OR4 zqlLIMtUMD(v2)RG@VBKRoSkAT+6(CvB%*x)ztipcfKeo zYy6bF5EYN={gn98OwLZRdw-Oa2|wjVKV=2H5a01pKF&_D`?;ir?|#bPkg}4qQ|!Tk zLe}|2MlgMy=<9$rM%UQ-nUb>JPst%FwX)n#32U64Vvn9DDQk93A|HG`)K7V>pAzGT zvr{a4zohKsr@Vlt8}Nslc+l30p9CG1oSkA%elE$Ae)9D=t>o+!dm7i$a4@9^XQ$Y+ zt%an6L`?L6TucnJDmgpFUKk}Qvwq69IIZOD6x(pH5NlYH{#bD#*WxJl@^T@`AdyPB z5OUG($X{qW5_jU_oz_bFw4eTXoK_x%*&x0P14_Ajx*`wNf^>dg$hnFv!n6?Y@{^DY z6q$&rF5a~U2a`-n-w{{7f9`LA?p-* zZ!eIZ7YMmeky~~E>2<4+^@{8`2&DHjLY`1$38F~6PrZ=m6j@JC`~D{6WkojAPQRwI z%zHzTp2I-;cNg-mA}{X=GGLsLdPSZd0y1!hkk1tv+Z|-kaYDXUq+%$@;7f#jugJN~ zGi05RUli#*9AxMVLbfQfrZ>p0p9+a3lk9|6T>8#q?Qt}0i;xOMj;aPpw!{Li+^tb$ z7rad!AKptyb47+t1{pCy$aadHN-}bekR26ydm6|nE@p8dsmLuOK}K_JTJCmNWMxB; zG4}}Rqsa5P{~RCtvXDWF+}#9Z+$JGOMSdX}@5nlFj3V<|f$X-OkO_(mX$P`9-Tegh@j7RpevzwD=x}2{~Aij*~zpo+@OPBL6~p<9l8u>R&rnCmxdytS7ik!;YnKo6( zMT*=C+wpzo3%N{@>H#48o+%`w$Q(SP5#R4xA!`)rwmr!H>xJAJBoag4f?T4fD}OOT zp1~M;(ASba>!*Jlr>=VC*Qe+i;LY)rfuQ z2V;VE9$^e!+(}4MkvH3eEEyprt;h<<;!6({l2s(RJIJzSLaebtJJT2`k6I}tsmSFd z%WoEvR^(fb-lLx~b`;qj7jN-nJ~Vd51?{Y53_bQ2V@HvX8AFe2432)F$P0{=$9ENy zRiq*FoG?a+H9lzP6h@;HQ$mu8Ol=2}KE~KlWa3UBCtYOhDDrD5$jP@GJG%w#?8+E= z%5%n!BJm24Q$I0w6nTd+^t9iN9YvmFsZVc?k%xY;d(h6DP9SI03P~z5j;(O!ZbH(E zln(?sYnG6#B8M@Co_&I`Ga+c_3f9g!tBoB+o}xeJ-ev44(vdOrybZ>VA}270uK3*8 z*&}FYG$Yda`0Oq`O$Ld?&^C~p=qZ2kJrh?lhF(xB>C=AtI8H0CV+_4;H=}8yXG6&6 zwICPG5@PKcBv&zpUVMU(tRlzk0dmP|A?ZoMJT4>HrFR)SlY`_A#?aLpjGZY#@)SIe z|Lt>QN0F1b4!sPY`ekq5E0~Ax@x(80EhITLNZw%yuIMAg+B--lF@|0_QAk#iYrBD5 zb*Qm3EtuykdV2NA#?C%LvIApi<_cqH-yo@D487()V@HwS_5`_hqp`DJFwegkL$CYF z*x5fwmUaiZK8Dea-hM!k3}6hsVFw{uMIK_FH3NjC4-Dp+&KP>*6d}ojg5-_fAZzCd zu?`NBe=&yMbh?nNA~#fn+?)}Tt_$YbXLpcW9uksF1<4VUL2iA+*qI(Acahxojj^Lh z2_xn0Wr$%LC!8{+a)DQ13BsnigPGAgOzr@%%B1lq< zp^vOEb`)vV0OZlN#?Jg;o}V~M9(%&rSr8=muy(TV8#@bwTpHBYnh|WnPeL+^Ji{3J zQVm)aePCHI&wDi>FLxG_QsmNJAg_!Pl2v5;sURB<7LqtBsBJ3qyt-UST9HE-Ltnc< zNWCHtb_03+Rw2pdL2dR#kT;$Yl2N2Dd&l4Fg;+-i^DJWwee*XVDMe~H4&G|ol68<( z82w87CyI$exU$@6HfXugI&6q3<0hBzbI5+j7Rx_b(BWQRJV! zK|WX~#5yjRC)NSv!xx046j{$0`q8ICvWm>7KlNLLB#sYio4yOk$1O325f2r4o-y>3 zUP9^>*^x8MKPCuCo)Fa5XCIJH=LpFt@-}1WXK5kUiNQRLI7&We>??Ouiu^Gef1bVL_Xi|>y`TO(oL0Wl z2jq{}ge1@KYzS%G6J*QRLNbcHz!>^x$#(SLIx~=`Y7JwkWw#TQQm7|`sBI4slvU`1 z!9b3^kD$a^L51HljJozBL1~3y zaG*vu@4>(?g&g*o#&#)MwA@XcA5_?;15gutM?qH|Y&fwb0eo9bQq0Nl0t?iElB`ydm z+=TBdIH0!n96{Da z!CaRx#wP5O1f>)jUIx_8zCut|q0=V;?P%XGC~5IeAG?;q9G(I@;|8WfWRD4QOY3S3%aL!CV6wYdhKd2}&t+8Ex%iFAt15xI*f$GGD>R?+wyXWLpn8R#=?B!!t{0U2TTtP77zgq0_J0Ir zf=EJca}-5_ZK?dl2W&oSh73LJt^kOVmwCD@oK}6t@zcv5D=48*CkEZ#_6$Kuh3Xk~ z``E_|N-0!29H_6oT2NY{ap@Nk?EA%A8?m#=X zqxf}s(68}Rfd<)a1tk>vH!lkZ+k*rp6}os3&=7lXK`Dhcb^{t}FBFtksK-R0UF~xO zWfYo;9vdHKuMw10==xzmN&9g@^$M+L*d1=aFUYzg=+`d{Pb2J~1tk>fUJEqRZrol* zfZuPlnym_BcUlh1LuQ8e`8Clu@V^yUkep1VLGadNJ&dv;QWjUZJlT zcE{WI2(qpW`gH~U+Rc7NP(q&G=;z5m6YMxlmb)p1CNb>pVJ8Ho6`H}Y zJJB92D5FqW4bYzUG(lN~hI0^2vX2y0uh2+_-O2X3f~>28ejVNvXo`KKpoBt?w*=bD zenL=Ep`#dfr`jI~N-1b?&2EAeSPUw36~pd6c6UKpg=RDC?rV=1 zRIgB9mT*6NmLTiupkEzY1MP30C@7)OGYq>2*p~@PDzuhi_dxqzK`DhM4+J{M-Y6)o z&|S23u>DU#8HIjFREXEvB^~K-)bWB^ICHD4$>J@r;7|>FCfS|@KtS5|mP?;RK+g?D@u) zLZcaWm)mC!-0;q-!--r;`4*?N};J=K26*ivXe4x-cSO~%&RpsoGK0G)2Tou$t! zbTY&48TJl>G77!TpmwG`P*A->cZ>r%%bqGIaZ}LNGdlsDZ7&d%Qs~GspmXfA1!WYv zk74&*`vyVv3LReobe^3Rl(;!)YXVES!hTOsN}<6Fh3DHp3Cbw+VJD!KcB3xRUJ7Ly zc30V51to3?+M3I-dx1SxP)eZ}XzN0IhMO?L#k$UffKQfNpe(8cy@L5W*~wyt8> zy~Ms-P)ebn76=n;n9)%KTy>VrtaZmg>pcFQH~BDU_a8!}vOw+6ryFt>Rn z_y+l_PGmp3!tN`mR-pqqjIXpO37VwP#d`r=WgjkRp+aTs7FXM+3tFkrO^iVq`x-&( z6nc#@=o)*ypp6P0-5lsz`z=A66&jKNy3YPyP|fW@ziM$3zus);+hx7wcxs#R!EW1!n?e&cqzJ4vB4MgiS!w-K~Zp}RT)-C_3= zv{Io5%YfF|lLf6)==}abciQs=ZB(eN70_Mw8G<$|ldPN5Qxln3om zf;KADv>NCkyH3z%g~oCcde}ZjP|ck|zgji~T5n%0s8*pTImbU@uM;#$p{u$AJ!-!w zXrV$|_6B;){#?*Xh5le|WNjPc7JezTl*8e1dpkiJ6&ln8=n1>Opv?-6?gsRvJw;H> zT|vKgWe0f5K0;8fLVP16{QSebG2oke#8Dlkab@WeaNu;ce`aTRzyajuNZdUw0jFm-XF}>br+zw z?1_Tv6?!HC^tL@$Q2K#jt`#_mzhj>&DDhwrEpG_)u6?zjtU`NF0ea7VNKopbV6IsV zyYJh77i2vgM2ErG_y_i8K^cX1W>EXkuIx>hlk0=I?raM5k=;>Hy+YI3aqI2jg3^x! zb8W(Ki+^k%C@Ar05FOSS=o9-WL0N@fVc7kLeSx6VW5HbiU3(6?OJ{14SzEDu|#bB<(n*jZ6-!7}`wQ?VzU+qr?C0+`mRqVaL*?$VkD)i|jp#Rvd`>{4sF9&n=ZV&Xk-B*zHN)T;; zruZNBBtaR4TCjv$?85~mHwJTk$UyX`eY&7}g)-X#S$!UO<%&S4s%G3cbwssB&&LwiKG!2&jSc zw6XQ~psmlbUXNEh^@36gUD_F_q4OU>8HL(%Xw^8)aisyj6#8HsP$Q?Opv0R&Tb;%N zHFhQlN-4C7t=PmlL{LVdQAAChlZ`Efo*4+#%(>FodMjva2=8<^cOEdd6q;NE)WUh) z*ixux1E7}9H^!DiT{w(eIeb(Rga7TIty!#%)=mdODTU5vP;2816O>V?Isvquv%jEv zg>GQS-QHPhY`qh-#mC^{J2)$iErkZ}3DnlP#n@74FWO2ttS_{eLJqXY+c_T_Tki&K zJxg0VI=>rR3O&W%+umt0Ncy2d6FB%gIK2ebD|AzHpq-pO1SQ@J+8V|<-qAT!P)eb1 zm}_U}6k|)FCVK;Qa;`GA6gr(~7w17^>;0guow&a1?7U%YDYUd4sEhNhv8B)v%+=MY z7%X+D(3PWsx;Z-uN_-Hs^#g}PcPA+*rO=S^Ks}rT1Z5N|=?7HnEHkzgTFH60r?bk~ z`Y>p#DZ5QC=T>7&p$ZQ3-p;eemO@jA`Z%8$TMCWo0o2#|!`S*LXlqFoP(P>T5Y|RY zp?4W=`a8V^WfXdFSD*pTL_zgIBw=?h1(Dn?wL!5gBr9KYk`m+*fsIyU!^+^z&GZko8=bwTy3Jqo09p;n_rMJm{1am#h z22MJBm>xq*p@Sv@4R?kJN`D&6^#?0`gtL#J#AiWtJHzfsXOW<+Lj4$MMmgsRN_`&8 zwV1X>J8K15Uj)&xu|Q*-Ck15``g1#=vCfBrlAD6L4j>xm{3@tkp$`TEjdz-&F|qXf zGMH;Gbd~sSP7gteuY%}MhTYwr-2`P78pp6Z!I>>6_0M3g5e&O~IB7xF*FkhFYh$8w zxuA?f*D&nv>D(tM`LAHEof1HkoL2?aE3|%RpvlhHg3{jvbN!8>aEenpj4mg>4WdO1 zyL&l13d$;U7;Q~;h6+k;4(4iwllb1wzJjdpg6Koqn&vDPlu_tChTVOf6@rrA2Xpc5 z!}z|=O@itb%5o6x=R74S{qJC|X$-sjJ0A&3{18O(7C;9$zX{4J)S0pMK&Kg!WAOhN z%ykvfK~Ak8>!%v%8>-Lg$qO)j4wnC4Ua)I*qwf&Pjsm6}p#Uce-zELOx)=Wan6g_?E+TIReg$Z~_Zp6(2El=G#altR@EYRjG2NV=R=D8sOOw9{5l zA{JCQjbZl~XON(@Ld~}aI@Z}+P`yHY>@9wrvrten9#r@P!|w6UIf60@9mW!#;H(j3 zl>~F0#9Svjj|)mERL8KJcHS41RcJp})Je|If)ae#1TWJ8E@0R_*=anAwUJinfeApT zINb!*E5r+o_^Hk~K}imyoWj>Reok{{3d$(7j-l{$=LA7kc`(;m47+DIe-o5a=%fVD zna(|evI>o77d^}2Jrs1`En4bOgih3TK)it16glJBHo!og)RM6dJxa&`RfAL0N_FBU%Jxy-ptP+FlujIEbD_X?_4=wzZR zoQ;B#je-i7^#Hok`KO?aLf13wUgeZvNF(|;4(6(0x4GJBCn%-RmkhfZXNaI|5J}kG z2XYCx=5r7DR<}JEcCU4gkPL|?o|)k|t=fxW_d4fHK`DjaVBxNJt`n3|Xf-?T4bG#2 z>J_@5VRw!5j-W)-psl$KyEi&N7+VT8nGCenX^2HH+Fqfv847Q5It!{-=(-(&Zgxfs zN;C`FdY@tU7AGYrrI5w(bE|W#v8B*Uv~`+D=&V#bEmP@JZS45ZGi4@HW*t9 zoyD-b&iTUFQm7Kwg7G^Y2mKd=U!e~eXzp^h7nEobw6&UH_ikr^pp-((7^|?D zZEPv@5XaXG&JD&EpHadqE^*^jv|;>3Cu?jeG?8Ih&S?v&D=Q6;)<$Ni~N_e&erMPH#+llQV zE-Q391ME9aTR};MUSfcK*BK-zrO=5Cuzn>r!i6>0w~mt zQS={9H$iEIwsZsf)EOrzqtIEHaO0mjGX-T8`XK@IxpRV`dWG&_fc?Vxn;>h)pkL=T z0NUi-BPgNJ8C`+CbY2mZROkr|eSFO6D?urRK1ZjB|I>*h_F>7Z(66n5zIGCVG79x) zfc=-l+p@T9P-r;=>^IIdLG=pV4_W+M=SV?T`=DQUur@Y3=L$+FbZ`>rJLg70Nrl=o zz<%#MAt;{lWP~P)4Dvu|kgj=rq9<82nP`at7F+obH0^721sf z_Gf3jAge>ruLX>vzc{l5B^3Ic=vU`NK}m&p}#Z0{>QmjP+Fmv7+`;Q zHVVop)Rg`359gnPvI>34@wLS%!QjLiK%pxbVE=U539@zy`t=)I*>Z;nN+`6M0oHc+ z5tLMD2?MO-E)tYdXs0Pau6v%Kv_f|=z{cFQf-(wqs{)F1Sw#)2de)GAiAa zptM2L2`Y39xs zWbG2PRn3)LbN4JkNrgHRwQ#Q&lvZc~$7)OWF=I=i4()(ix$hcVorAW%?FH1@{n6M` zsD{zMja!4s4WUq>Z#WXRbGr!2D)b;*d3$$^AgfEz)_ntjc5tT)N-A^@r{uQoamJQH z*OUPz+)Irug_i9A)Xu%j*yjj0CO*_|pVtxyk4xbaRdBO+`mbT&KNF7DaJR`;N- zy_x`Zc5g7Y6grYYt&5vAwiLRCm#1Cb_lzxt2DAd|=Kf@C^$6O!k3Fip+i059p+YY( z`uA|V3Q8-qtT#}tJ62Fup>J5dJ>40CtlFThEezJZ+~bWch3;Wz>+P;KwiNn_^KKva zZevTKZaskdx-T1BJ%hI1WJUFJzcjWKI&uO~e>b)dT}~_XEhnJ?Zd*ZFg(}+t4Ri+y zvU&w={f8Ab$lY5|QX!l3?qGMJv8B)>Ea4FM9Ahhp317JGv zGyKd9SE0(95`8@%&gLmCyy|E0zj30f9WCtTejypseujs6N(;_@p3}JuuhYU*w|`eg^;Z*j2-6VPAK=WJvoNw&y7=%!*|AmKOGNkC6kPPi z)Mig)IKaI{GNk+rC-RgQo{41Omx9F)bl;Z@SwF)%p3=h4eumr!9H-NVl-po`q;Tu~ z3?DNCEp&ohdSEWY^|UbE-BmIq26#R+#%a|@l|VDy{RAa_L|s+yGuJG4iJ-KPm`loa zJ`Ti8?h`;Kv0R6`H%NwzpW$epvRv6nhW6u-VXph8WZ3LyxEZHaQ&@|KyWa^)4D^aj zT~)uZT=U$j1L*!jA2FAdYiG!%T)9W&zvYNs=nj<(89zfKp0Zr~Ml!T!=sMD!FBzWm zGmOA#)yo5b7Q1H&s`n9fRgKyOXo-8hpt3<;k(o=%^%xGMT)AgRKkJJO%iX_AhJ>Ht zCZ4ifn8b=wKb`iQ!!mNVCJ?hrxN&|t2z-GNSU z_c026B)J}M3v{BpNKj_iKrZp-JjlhH+@o1txpq6nz0Q~!=4CjFr}XC0NQN&tHJ|Ff zAsHt58P@XjVPyE$&tM`PoYmq*6WaaT)*jGtj1Pif(9odJz;Oe17C z&wXApWc>_R@{|@njbu2#4Kl27f0GOw{R}VjlopyD>^Yr#({LVZX_ear0MWtE@TYHK zOe8})*3t#;fs!FJ!gIQor?haC&QM}iwc)*ti`?@hL%pA2I#21t+DL|ltfhuBvlcuB+T>f>!#7xujf2YBRWkx{R%tanFzpSwF)8JY~7Ajbylmt#^(4 zfMnS0XE+z9Rp-;k>)qD{S);uoOXS^;-rV4RBPi)3iPs0vn;YHo6dg_ZNOG;EH*4Jv zf-*jmTo19_H@m|GWql;Mo@EJdarYNwjq!?+i}Fh$4@6Vc!As+j;db{N$&m0f)bTWH zS=JgH=nVXti1;1udZus}`WaT@wCdemfbMkP5|r@~byfA}#m`;t_kuS2NOC>KSa*-x zU^*2h#(G7TTp5P?d)-cg7W#;}RvA>=_ASY6q_dNJ|-yTBgu6lCxOS^cLim9 z#9UJ1Zy}cwH?XR@u*6Th@fq|x>nHsPDXKOP2YSX$2&(td3l2~Xb3Nw{7PQ$%lIsoT zdfuHTsAfFQ=#1oQyd92SbdMC2@R8)IK@!G#z`q z>_+xZ)lDkh>NeGl?8c@1rZuOz99%iRiDkJRtjfw=!7VH19dbTz2r0C2$5f>q zE$+&i*lu-YCG*-iEpL!hGytjbUB03>KE4T0@r<`I1GjB^d=utq&<=Wf09JRmhqW?z z=T3H1uk6(%NOFh1cDs`zYS6LTh3$oIU$_q;M+Bo?U3JM}zhkf+9j z>YzY8;O{6n)-UwM{!cZ2Iu5nJAdZ9rL$&Rax!o3j2?%~oY`affPQuT z`gEH&cmC4l-42<*v`1f^&dU@{H)HOS#a8$3J@AOX{KWzPPu+9R342-A%=wcREtpw% z$n5!b)0Zvp)g3+FvKB9yg&&^jekhBC<5{!k;MlROB}Xruy%>kCNwUDCKndr1hw~Rr z7&U3+tl2Xc%$mKZ4*8fG-Y%JY#O%5wW>4p7oEFL*{|E3|m#zG)><7z{=ECs>am*jgGPGEhfs)o8RrVb6*d>beOF84D7IVElbs&b@Aj)M;o;>11B zPg3G`q56C5=1TvrA^j8nd;OiMe}&UR>7NwRKjpvIFXjKuX|+}TQ~!th&vaWW{d;_m_B#D31WV*GBM1=GsLihAqoM_$m`}UW!%Gg zFk~TuF=Y9_h}HV!&z!p)Y10chg3HqQYnSX+a`=9jnQgnrp$m?f-DC05J-k5J!_&QF z!Gd{?H*PHFGXrGJVmK;j?Bf^7BrZw+PvLB71LN_2^lL%w9ZcHj;RXds|0LUp`^N zl)gQC)y-ZwcYswle$Tqa)0fSzn>~M)oE)`i?hGrMkyC@o^u z6q@N+_rCd&@NA^=td}WTM2jgnD9dAtuyDyDt8UJ`>4z*9;f$qo>Sjz|Jli^E_M!!g zd-d&S%J0>$HSivOxAchlT7&M@>|dtqU(Si$gPgA2y=P#an$o$!}5;G5-zDTF_U6XE*>z`gX2#th7-JqW(buWK%X4n$! zUcGyvf7Qu|^h;~{wa}jZNHKC2&7M9hG?Hb^)GeLAbn)z2y{tL&rynsppOj-vclN@e z1LYlnnt}xmLxzgN-P=?WLfq`d9KGy*Jm*qGLb6<#$+eiYkyqwmZZG9lOO0Vsw`|FD6x*LJ3O9{$aKXZbXg;Pk(OyEo z=^}IH&YL}dfnQ*TBELs(y%@P^2R&r$#Jv+Ed-e?dsC=T^5xl^_ZpqU5vxiE6o;#D$ zMKcc_imRJ${rV)j9g^ra2Q4%6@NNqiEm$&pCZ@@5=tYP}ewjj5V>~L<)F6z0=&p=e zXuiT#VuFgyC%Ld4=o`E`8iDREbLxPBbt5N^?QPARyJ+TKht8d|M8x~|?B8!|@;*h< z_bnptS47^whWQf7IZ*mSw2K>gr1)O?Nbx;+r1+k^nB7S6 zz4S%8T5tMLq&o>K(w&4A=}yA1K$y3v7dCJBbA|1P0NfGDt+`cn=;dV%^*9+1y5i7( zdJT{UC??kxf%Lsif7WugqjWc2pZVmv9rN;tSx>!g$9#I-j*v@ah)9dX5zkj$81`jT z2N9#aM7vH7n?@Wdx)B#q5-pmlH?(sF>6qA$1=a0nvi@ zFVc-nS1+1AqTfqjKwhAKvGlbfk5-M5N9)GOqm^Ui(b_TcX!RI*w45g9h8*TVC=jD_ z;z;qOQ-_q$TW_8YMys4SqQs<*R)Hvq)_{nk6(HiM|00gKZ_2I3@Up-X%$N2p9Gc~N z#LN^0LwAn%+eUs}a#-!%w{S~%a$Sr0^tu}J@<=@v3=;YDx;$vSVzHypngnW$I8sU@ zjug_Y9(6o{5+jZ%G2$Xhw4*sCQGZNPLY)`s2NVg0-YTf4?lr8LLNNu3`mbyMSlb1f?lqZjP<;f#%dGbg(3k*t>Mx>Ey7ipw~B8`+!q><8zG*UK^>XMjg-Lz?P%{VHmc0T8!4U<>++#K3(ejridoY|loVO+7Fhural}m{ zj`(RxqAQ!-uh^2w2RaAJZWe&i3d3EXLQ5$lj#P{h>y|@tj9B}W6GwWLNgZ+3h@%C^ zoqUu~E2l$79#LcBr%ui$EpRcB6BkhuDGP7z6%4Ayn!}Sv6nX10GzaeJnp;u9>n+;Q zd2&V7y)P$@w3P8T(ozEpubhoIqQr=cD2Y_DNgZi!BaT$D5l6f%xbA?P1=k&Ud89C2 z`bcR!d89a=T$cyktWbkPY-Z6S*V5*`Tfxh0xr~mu!V^4-~n^H<30{0`Klc@fyGl%8)NcldgIAQs`nXC)QmuC)QmuC)TB8?{YB?3yg27mvwv*kD_Ii)Vho;%z(nN){|>B`Siu~M4dJIqg~#}b;alP>n;y@&z=RR z1S5`=(ugC4G~!4ZjW|+7BaW2Nh;;$c8om9-i`=o0;Z>js>6J_Xx(RdQs8^CY;+5$( z5hX?(QDVeJltik=q>faL5l5=Vh;`M#9kU#cP9CNvG2cY0Ox|UXDvK!dGDYNGtkjON zT?(%OjW|*}G8jS&5-2eq=qk>MwUV4TQWB#?S8*HsUVDYq-a-Hfno z#JUx8;z%W!)Df?YSeG7UG0RhJGAGt1b7E~WC)Or&;z+MCCX19r*9nxEwL!FYJ-JSg zTIp3=U@YY2+NHc)`;?b!r}FYh@#W54w3tS$OG&THyN{82_vE^i`SiM!dATlSULL7? zPk*HJo;+Gk?=Ecw6byAR?8zhP&14mtl~A4LB1P9jPOPgTC)Tx)6YEOIi6g$|)(+vt zskc(p?;yh`FN5|8`u(M)&H&J>*n2$1-sCCvE{~B%9P{)?JS%*0%90ki=F5pAwQN%B zT1GYa+N1R#+6!D#&1T`M`w_aG5$kT06YE}-6Gw)hQKG96 zsS7?Fk(Wn|dg&upy>S*PyC;w8De`WFmp)Q_PaeK*4^(G?3-`oOtDx|`Npo8{QhFoSrH56s zIEyMTbb-V|7Fgos#JVDLVqKJ+I8qd&J6e%qGEysM6&6YD-OmU)1fxFCiU7>qtNVOT z9C68{j<{54nxj$a8xbW%ra2>y)Qb^ELaGr*D?m(YFBuBV;xtq*1ZLe7@xNgA&8OEj zke5eFFRd3TyhtNuFVNDcM6V>;rCbX|44M{-STy2@Nh6NvHq)hEUcsb4i-y*3W^6_4 z)m4i!|c6NVVT+MUh5I=Do{XIJGXDuS1v3m+DeL zTIeD$C)Rb56GsdhB@v7M!YZhDc?b zo*L>*sFVU_^QDmrEKp*kH4}_>#8;sU2dQ`GC0dRmm!X9ota3L8Es)6mi>= zM;!O$5!XGrb{-`wxF*iawf?+Z>(9%J>5nvgZmk@uT2CIW2N~O;nq~b+NDs+T9`hDx zNRIU8k__^Kmt46gHlyp;f=v!XTW{Iidxp`Hn1QJ)l3l34vKMB&TOzt2M;);)*AaxZ=qpu6XiDmov)( zU4!(nKm+B(S~=U9PL?PZbTCsvDTdvYu!0<5#5nGG`h8yIVHLV zAvX6Q(HV+9i4j?XdReq8){NA;E`3g{%LB3LoO-b2#JXm3Vy&A_6_{{xVyz@6E}|q_ zy`no>y&~4`kBn+Eo(+xp~3Xk+c zjf~Vq-h?yaNJA8P3(kmjxpTTBm1R;#D$9r?l_le_$X&YJ+}^wBlw&&Dw(=Lb%a_w% zeqx+_vnk!s~gTjaezBaT#<5l4D}5$g)e z>5lXOlR8p9BgTjG)#t(dJHc{=z7-ZJllQ(L~w**_LQ2aodOjU%c4(SUmC#c4B z$WZ#co`NOv9*QgAoRB_+ybw~bZiVzKnx}tJGN35YElxMh0M{*;mq*8oNgo|AMjmOt zLRW!#^}6v;xh8oeI2mz~)DfS&Ck&#Y*}I!v=tg6~_f}C*|Lur~vV0^fb^%^+mW0Y; zpT#M36(m)~n^OfEB6`m%ms&SNPF&zw;M}UJz_Y+PR^VgAIkvSo^&{=*4XUl>(XGi? zVg_Q7RbTF5PVI6&Uy;>dE?=ZmdG>TUP=(TYqRmj?+KTmE#Bf~~Q0p(wibWEWEmA2aTclQuIO3=gM_e*uT>D`!J5sSmNyHr^j?|NPJ2sNs zEQ$++Pnn@GhcZfr-`12*wMU#4X~b8NMqCwX#8Z(*92IG#;35rQ+vmSWCv<6#)|U*r z(7sd`+L!7=`%+zKUs||$(Q1`KgjOcdVdm^;a=FyjWk!b(sV=iG)n)djy3D>bQqiI} z;)zHj{i#67;75Uy`BGgnU#d&yOCx14%cyAmc=AZ;%pGT4aZql=y5@4?NC8diNC}Nt z7ZFOl^>@T(!Eb%Zr;k|m(nrjCa%~q)S@eFW4|L@qhZjqAN%L}DJ$bnSXpQPxD1D8UE+}tg{owspf)#k-7w4_o3Bv;t zbLd)4teT0_3&@*VEepz$@|!&Q&7Qo()AO_^Ul)>p?8)y7$^Y==>qGKZ_)2y9 z`O zc_t)ph_8UBUs+GS+_+_R^W@1Mrkn{+zPl$+dGe;7e6A-?d-5Tk{A^#pC$I73w|Mf6 zp1i`7Z}8;xo*X}5Bd@PKd9pSs=ben$DvO!&FZASozwPMBGoGB|kgu_xe4{7#%YUdR z-{i@wOmgciPj2;0iX`F5FY)Awko#sa{cwBD|$^CKtQ%LTQ>)%6ie_WRhHuV-B*DXVGe_VG8$^CJi^yJ}joeIhQ zah(py{c)WM$^CJi4axm+T_2MBxD*EOCzJgyU-JUp(`o;*CR*Lm`mUOD}7UGK@mB$qG zet%r2LUMmxr$cgoTxUJGv7R5-)-WUS<^H%%hUA}m<2~)k{eJ$NCqF$TuZf$ucWy}D z(UV^gk`M9Zt3&cBp8Tqie6AtCL{A|#LDC%jk>H6eK$Pu@Hv@8!w23(3cO@*P9+lqc^L zk{{*CyNBc}Jb9mxe2pg`6p}yc$&(@Z-#z)5ko;>;J|QG`@q=irhbbX>8&AG(NZ#9% z9~_eJ?#X9`za6kh~ld zI_u%0ket80O8I3W`9M#e3CSmW@--p(Tu**$NPdzh&wBDsUcbH6lUu`+BJt(7dGcgP z{-h^Qhve`0`a|+>ef=Y}{t`?;^fwujZ|}*|A$cE9o(;)&^W@e@tv}`K56O@6^@rpu zeElK$4Zi+STK{@qe@OniuRkRJ%GV!~TlgtM)`K-#>u=%7lOcI`Po56RM|<*YNPeKN ze~i|@*w-JDpY7`p$*=MChvX0V`p0VhulV{y^3Q$!A^9J^{*b&W76wv36a^hvZfR<8S)^D(!B- z^QfvkfKMy7AP4~q@+A!4<)a~_Eo~KH`b{BiLt8+K@=n^kZ3Af%k`x20Fk)2{gtC5h zWq}cPvAUo|5fK$eMFCxw!15)^IxYw-vXE6)>axP#x#xe9_nvcayZh|>JT!TKbMBct z_nrASK%N=l`@#$1$HSx3-Tn*UiSYBdzwnE=zwoQMf1BI?7Va5-2V*MZ|45XT)&(93x9$4KhFJy zf0_HQa_evB{;OSofctm4UUGlo+qi$-t>0r$TrX=}KN23Tb^ZPDLim~RY@J)bp8I#X z{t51XzU$X>f8pQZ{uj9Q|H%EjU4NGQuXp_o?l1gZd(k>%J#PK6@TAxEx$vmZ^>g8c z@Bw&sp<90?Jn47+W_UE<`uE`lJdNn}2s|F7diEFKnee~BOX2T&7tV(bZl9y!x$p!Y zUF6oE4Nrylzzg9U;qiyvK3|4s!f%I{!XJPqLvEknz;oe$f=3s-_3xZS>yQdR99{@F zkLa~|5?|u>IRl;vUk5LRUj|S9%I)(-crN@lc=Qps{yumr{8#Wo_#fc$N8LWV?2YR} zcnmLv&wwYFx_y?wbK!M(beUWKQFto+3-Chtt?)Q=`}_o+34a=13jYH<`Iy`19sAHa zQu?8{Iw+z;odxJoTTpA3&b>GnzBneY$5OZb9_UOn*SQ`CojBRm)WWq5RjTfY^a3jZ0r5dI82{+nqYkKm>7C*jFw z-9E3tbK!5_kJcf&+O0njo(i7|FNB{4kFRn2bigy=L-11gHSlDU+vgT|F8qh^=vue_ zF?cHc_wYja`2A@e;=gwL><`a`x57)|i{Q!U+&(Eh7ye+nMON8#~ix6c>gnef}- zrSPA^lfQBMJOj^#|0mr12e_zu#rDrA+Vw!355fd?CCPejYsfTX+70@L2ej z@I?4c@KpHs;F<7YcrN?}cp>~vcqx4EgJ^xC>)rVu2ako%g(t#S!c*ZF!ZYDlz;od@ z!VBTwg_pt~hDSHJ^M4*53;zo|5kBc)T8C8laqvv|Ja{hrgYZK5AiNZQ6+F7po&U}7 zSoq!WMEIldRQOBqO!)YijyD&+KfDm$3NMA929NS2s$Q}EGm2K3Z>pcuV&Rv-6XAai zPvM87&lY$t{2q8I{4sd^l_aWO+~=hjpRe%f5Uhjncf(8J&G7i9#B?9)KOdgnlvF&r z-*dVDO-aS0ej)e2DXDnWui*YSyM7})6@Di?7yb~u6#g7M{yVq-8}L;4o`+(6ginT- z!cT$6fA97`3!VyJ&;5mOt{~-4l{#))Z{LkE9_@0N;I>cXh`yUNY zg(vV__}TDMcrW+=2e<#HxWDilxxeu5a)03ubN^f2{x5KU;csz&;qN|z)}a)BJiO^P z>TmwDhJ7u7w+R0byj}PpyifR*@J+&Rf^QXmH+)$5qwo>oFTtC>;m&{Dk#xK*!uN%@ z3vYq<2|pFSNq7q1Dtrh&EPNAuMEDkX(>LAu-wSUM{v^Cz_^a?f;S-Odb=V~QVE9(y zGvLF*m%>McuZ1^lb?1K>yhZqz;O)Y{3GWkrKYWw$-@vyDe;qz7ylFD6!-(*s;Z3)@ z^PdfG5q=K5UHFCYKH;B%ZxVhpe5>#uz=wrD4j&Qz3cTrC?))bljq_jlLGX6rGvIx~ z+u@spcfq#`zZ^a+{5trE@H^m5-*)H!5WGeB^YC`zZ^1M8=7?VV97F36-$DJ^r@#y0 z^Wf=s-1>9j(VedM!*k)EfhXT}>u-XW!taJ>ce(YCz~k?^{vx~(9vw@^o8Il#?+cH< z?|KV77k(-{`GH%X!b{;p@a%_f{Wb9T9@oDLFNEIpM*z+>#xFd;S-Oebx3~X z)*lQnh0lOzKX&Vv!sDN~z7}2xzYLz<=hlA-9{tqyZ^Coo_rsH)x%DNy6#i#;cE4M{ z=MJjAcft$d55v=crh4<^oPGTc zo(q2iUJBpyczo`UxqXg;r^4S4&xJ3Cm%_Wa|Ko1|%ecSrFLHn3w{d^r_i_Ix-2T7f z{=)yj{e|z+LhDcpkKyr?ZvPqZRQM8jF1*hDg@1(mKjrrS9QPOgb?z_xN8DfdQ{4ZT zZvR)gzwiks&^qM8-vcj&PlLx#yZujxr@~ipf8iH%f8m?B|F7KsU*-P7@8SN!ALstU zU*`V5cKh$tihK}$AUqd74PFXwgU8Rf{X4n8@Q-kR;h*RJ!f)mN|Kj$)kNXS%HTM_( z8uu5z+f?MkZ`}Te!&BiW!E@m&;HB_x?q5>>Jfhd-@Iv@zc=}tn{u}VT;kHAae6Qgt#jU>z z9>41P&G16_-SBk8t$zd_{fFx>!gJwo!IM9@_4}Mi$5jfS0?+>F*3W~-uep9Myb#_G zPyf@c|1>=Mlj~oB=fb}SPhNNHAAy&`{|%mPbL+>=pyQ4I?D~H2Lih>r^uOHtMeyhi z*E`_3@QdNef4lY9!b{;_gJ*wn>wg4~-*o+#@Iv^1z|*(f`dwzyIz-XzsCuome@4;4 z@KpG8cp?0Bcs$PS(*e(fe;8g0|13Ni@AkPFo(umTJbIg3KMYTWzW^_UzX^|ba{KH( zi`FL-ejL0MJ{O+6-R-jyo(sPa9!+rTuYjk*Z-f`Z?}Wz_-98V&GvUv{OW|+8lbzi@ zd%c&|As2o$Jle&rPvEKWv*CsC9(eo?x6dcwnee}bm%_gdPj+?t{2ZPO|1CV)&8^=C zPlfOCK3a!D_>u7Voo=6#;hFHW;HB^$c(S|O=acYU_zm!A54ZkKcq;s#;Dzw#;c=7O z=S_Gfe4mqO9ZKQN@MKT7&jNTZ{5*KHms@`kJQaR5ybyj1JboAT;eW6E0rwI9C_ESb zBD@s-CikD@_Mh~AT8C8lG4Nb?0xyN11&{Z3`>*Hz!Z&h%;n#70;osu^`?&odcq;q}cqaVc;kodg=FvJ7!ViF#!dv0d;qLqw!DHbmJP|$wPla!SXTrC@bKwQN z5dIXr6g~ovj&SF{^L$!|Sa=LigwKSh!rS4Q@OAK9cm^+oZ-$q`x5A?%-T6NNkA;`; z1U?zp`|I#b`0fjEJ_tVo9vwydx3R_-tS0q!rn zU5kEpGqoxxer`xxes-xxerix&H}n|8b|$ z@g~CehiAg4!VBST@Tk@8U+4b9FXjHizr_88Z-u`I-wio74BsYv1itfBnh)1EoleIa z!`soP1>Ogr1aE`q@O9&8LpS%CPW@M+{t9>oFW_6?$%#~N{`Z-E-N*IttKiRZ{~1(& z7(8mD`KRy|@EBge_lBPYFX0LNgYbAJ^>2a?!4o*wZ-!^0{tkE!H!kZS+Jh}cYcns(M`!C0NDC$pyFM+=e`)!A(a9+>z;TfF& z-q{E*;VtNM13W&B=E>L5UGR1|pFfYnQ}|x!^D=x0&iOfU1szuo=bStgJ|g;@1dmU5 z&!4m48JzQ>555)7^Z5*X7|!$mJ9r77g!zv%Uw!xUyw}$66(x&lJ}8eKvc9+Xe$Ku= zzclrcxnH!rFZ4^ckG}u&A5kywFFoPRs*k=;^?t_3MfW|+q>J!H`sdBRizOOj{eRr7gYW;_gO>BcYdj8IQ zzD?%7(_2KJU)%YN-Ov0O)K4{is(QJer=b7)j-mdW#?gRzc0T(@Ir{I6K4;i^ylME- zX*_Ot&)*IO>OULsuNbe^N6z!MK>zz~pWUNRPE71BzjG+i zbyTaJHg{RAZPD@-wOZ6!@2{`z8W^ni*9O?po(yZ~s88 zW5ZCix_5nFcYUzl**s(VtZDwD+M2GOu3ATbf5*kOde310#nGDnj`j6g=Z5v`FE&FO z-qlRypi{cKr@g;-b!~0Er`B=NP^+10_lCjR=tG6(_AKo0-Ox8so3rqQ;FeaqrDwzX zIX#Pd8b{QYoiLTR&HX=ZGtWS&=3#p3aWl=MQ)t`#&b9S{_Im%Eo@#!Ldy`wn`pGS0 z-NfwegY0-uVir5v7Mi^o7nq6D(V1hlWwf8%GS;n{{hWqRt8tXxw!LxgiZt|e<|ukP zv(($LztQumq3hV^7TCJ|v6!tI+t%IhoD|`LQ2)^mp&)m z+{PAN^&c%TyQuP|)jV9O-q$rVx}@IUJN9mU$530_veAuI<#h8zpRvl(cU0N%wyVd4 zMdMS{s^_Ov4<1#IJ@GsT)6`D))_NXwWNQ6Swxj24tKHEP-ZcAnXdf1(iapN=GSi?3 z4y$6{(^;$P(DT5&2j1%6rSG|frnkQ}J&Q@ruhl+sS+l>%RR2WinQy9z@A>U!e!gd% zR!idVP0vD7y#tRoqsN4)>cBI1=t(!K+WX9-YKDQuqQ?xYHuP+G#WVdYj_1d!a_^It ztI5!VAXR3jTSRqfxQJrK1+d)P`ToHYA;P&lb- zdX%PS|1K$BH6RZ$jauswtcl(+Q}U!bvfOlVS=d#es(`(mAQB15f^< zD@Rp(AG}tbC4t4Fa8hk3oD@?yDMmPH4=k?tIn!p62q)DCk8xB^;iQnWU++i+5kfV1JG)MkZJ8%|1XI4PxY((K57Op}>OtY8m_A(1{w5Sos+z7J#S~78 zeNTI@&OiS_(pj&XZ1+*Gs(QQ6A5_%{C+&g7qHt2>6i$jMoD?IRvr|RPfpq?oRlM+lp~y!Po;2DZo^4Eango`QX5W6Z8$0Q zJaoG{)$LDCs+fLq((K=%4Hi{wFCwKBPMZBaD4bL^g_CCgE-9Q;wapc!6i$lideiK0 zLgA#U>H1Mj;iQcS+%-s%@?)rEpSA z*PCX46AC9)P1lcN3Ma)BPKqg<6jL}Urb|sRg_B|mC&hH-C`LGG4=fgilPafhQcU5b z7~!Nnu(${(RgZAe9#}C7Csj`2q!{6(9O0xru*3)_RgZAePT`~+;iMelq#WU-+=i2S z`nC-Vr8bqjw#lVS=d#S~78DV!A3rKXs|Nil_!V!Cn^Bb>Ac7K_43l~Xt= zrf^b>aMB)FT!fRVM>uH@tQdupDyMK#jBrwpaMB)FVuX{bM>uJxa8izNQjTy^j&M?L z!)ccMe|R=5l-h7oYQssX4JV}(PMZDuqi|ByHdvI}q)Lb#*=27PnvB&X{LnoxQ!@}2li?MMwi>j&`dGq@jx32DqT-Wc{YTWk3vijpcK=N7}Fb&W1bD66-Sck5r{I+ z2FfzM0b!;$AkFj!#F^eed8T5HqD3(!i(<+%#gu1?k!RWiJEfnwPEhp}M2aa_6eG{H z2ihRdR6X)cdtkrFGgVJHq!@Xo99O0GKp*6ps>d~^9C@Z3d8QnBrW|>u92cZ={{$%&bhUq%^t&#qnvztr zf0q=1s+uk&&Hi(NvOrZ+SZekk4n?S{rb|~b1)pL{AI*Vt%|8=_r0RkQ(;oPgafR!8 zN<8g>B|s4BdI}2V$Vcs=^DFRaBUW@D$~xu9C+&d~0qLab?V0NSjunTKQhP!wwc(`H ze%eZHI4QL!j8Yp;N-3N)dwz$s$`$|N`F^#us`eisg_GW;{}3shR5hKpn*9@`lSfzk zcj@~@yy`==zgn%D&<`1!{k`dQRn>G=Y4(4VbWW;j`aw%EU74EwpALnSs-|$#?4Kb0 zY@(_WPTE7~Rp3)bIO#rtWyFs}x}JW^T|0%7a)gui(D@bkv=L6a4~3I*gp>BbiGXlY z_4eX$f5(c$NvSkcFQqfONs+!J8&Hlroa8lLulapc! zC&d&_ngi#WeuH@onL`Z8{wq;P&g?^ zIB5@@2nZ)tZ_iZscdR&^l-d(gsSPKk_S05s!%3+8jbkR1{9Cn$Ahh z{==awQ&m$qDW-5zOyQ(CaIX1hf^bq@5Kh_ypEANp*HbuY4=e$~N!L?2DMvVI51n6u zPaEN+`%pM3M>uH@oCpXfRd3H!_tzLWoRr!VQmG9mrS{WSYQssXJz8jbkR1{9C zn$Ahh{==awQ&m$qDW-5zOyQ(CaIX1hf^bq@5Kh_ypEANp*HbuY4=e$~N!L?2DMvVI z51n6uPaEN+`%pM3M>uH@oCpXfRd3H!@&Eleoiy81QnSq`&Gr-5Y!gbeJ#94GjM7XY z<#C%*9uFKS<&>vBaHy12p8CMSQda4DI*mOZm?xc1p8CLkDX?@sC6>nn`=!j%^>iA0 zJg{yQTe_Z3SC0pdi!NJTPtm2FvP(OKm&Ze=VPHPUFWm?M=GhSX=n-L_5tLz`4WZRQ zig`v*jOh)?G0%qJnHM?*5M`cLlx2DY!pyTFbb27p%!r12$W-@)nzLaI-#~|Mvk=IBJPFdUEwo>nmwzm83ymH9Q87H}PzsFB%$EX<8$b`KHVQSmh-l`kbg@&nZ7*?&p^uRFR zwuWJ$N!n!LF{dwLR+Q<$4n1yIWf3pMsUl_;Fejz zE#|xlP1}UKXOsPx2k$D_E#70bTfE0=w|I}$Zt)(G-D2ilt1VbId-43*{3Y|uJxl2Z zru@Bg8_~|FHt(DzvllO#YpNQy*elA=!X;$wbtg==IK#w(Tc^jvAd_PSUk77 zcj}6cRo(TdZ^Ph#sIGT*40c3o%neot>S9xMhtt&;)K;&%pth!?t9xu~b&pj$4?FwX z`i`!iv5j^PwW=%KAvIdl*WcAMxJFj2UEkY76?Wx12YPGkI(jj=wXjQ}6GKntOT&>&>(0ESfUdu@>*v_H1ZgwV|uKb4pid)Lgw= z*D z%%9aQa!paMJtLay>u^)tb)BXOzoVgacU&65-=DwQl$qUhtnXTF=FmG>wKr0oUd`qc zi<-@Sde@tK?;5MG+OXD)>*z7JrscO?J!^XT`;Jws`s)|*yY8-@I)880jBjQ9|N44> z8C~64neU%Hb9`dnMbS(E-^bme`2)9M=C@IGU-gORA0EGAd}7{3(F#Cp-;Mpj_m5^d z!F<|F>I>BEDZV-bUu}57DmX zA0B_#_{6-6qPqYw4tRpG>RTRf?nrK5=623eb?rdf^_LtjtV}Ho?JI`!- zt6}~tcS>yWN*pNfhv(1x;jb5%>Ngw44`KWe#`FE~<^1hV%paGSf2vaMw*}+31okhF zeb3Rl3BKAd=FZ^m3vEa7)8@Oz@xvHD zj0M{|T1nsV{qp(i=f(JJLShRuOo-=8qsQjY@2@xCH12;B#&5#-Zymvv^p*F^db1cm z5BIa5cN|sh!iD%MkN;~J&z~RPr#-{?!Gqm1E)o517vo>U^8;QxoyMIc>gE3L72{jl zX4?@hZ8Uz8yZh14pW8lYzS-UUgUco2=K?e>p@BPE|HsYPJsQUIa|rhRUylE+8C&g% z_a86mFz+Js{Dc49{+~Cs)kn?aCu96%j31^pqvtmt51$8{&Dh5MZ(BMn$Hap_;hyPxy^3AvZr!J-OFIIoSHoWBi{|CvK9)|z` literal 0 HcmV?d00001 diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx2/cnProc_gen_avx2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx2/cnProc_gen_avx2.c index cec05379f0..b9a8e19f21 100644 --- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx2/cnProc_gen_avx2.c +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx2/cnProc_gen_avx2.c @@ -3,7 +3,7 @@ #include "../../nrLDPCdecoder_defs.h" #include "../../nrLDPC_types.h" #include "../../nrLDPC_bnProc.h" -#include "cnProc_gen_avx2.h" +//#include "cnProc_gen_avx2.h" void nrLDPC_cnProc_BG1_generator_AVX2(uint16_t Z,int R) { @@ -12,12 +12,12 @@ void nrLDPC_cnProc_BG1_generator_AVX2(uint16_t Z,int R) if (R<0 || R>2) {printf("Illegal R %d\n",R); abort();} - // system("mkdir -p ldpc_gen_files"); +// system("mkdir -p ldpc_gen_files/avx2"); char fname[50]; - sprintf(fname,"../ldpc_gen_files/nrLDPC_cnProc_BG1_Z%d_%s_AVX2.c",Z,ratestr[R]); + sprintf(fname,"../ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z%d_%s_AVX2.c",Z,ratestr[R]); FILE *fd=fopen(fname,"w"); - if (fd == NULL) {printf("Cannot create %s\n");abort();} + if (fd == NULL) {printf("Cannot create \n");abort();} fprintf(fd,"#include \n"); fprintf(fd,"#include \n"); @@ -79,7 +79,7 @@ void nrLDPC_cnProc_BG1_generator_AVX2(uint16_t Z,int R) //p_cnProcBufRes = (__m256i*) &cnProcBufRes[lut_startAddrCnGroups[0]]; // Loop over every BN - int iprime=0; + for (j=0; j<3; j++) { // Set of results pointer to correct BN address @@ -165,7 +165,7 @@ void nrLDPC_cnProc_BG1_generator_AVX2(uint16_t Z,int R) //p_cnProcBufRes = (__m256i*) &cnProcBufRes[lut_startAddrCnGroups[1]]; // Loop over every BN - int iprime=0; + for (j=0; j<4; j++) { // Set of results pointer to correct BN address @@ -230,7 +230,7 @@ void nrLDPC_cnProc_BG1_generator_AVX2(uint16_t Z,int R) //p_cnProcBufRes = (__m256i*) &cnProcBufRes[lut_startAddrCnGroups[1]]; // Loop over every BN - int iprime=0; + for (j=0; j<5; j++) { // Set of results pointer to correct BN address @@ -295,7 +295,7 @@ void nrLDPC_cnProc_BG1_generator_AVX2(uint16_t Z,int R) //p_cnProcBufRes = (__m256i*) &cnProcBufRes[lut_startAddrCnGroups[1]]; // Loop over every BN - int iprime=0; + for (j=0; j<6; j++) { // Set of results pointer to correct BN address @@ -363,7 +363,7 @@ void nrLDPC_cnProc_BG1_generator_AVX2(uint16_t Z,int R) //p_cnProcBufRes = (__m256i*) &cnProcBufRes[lut_startAddrCnGroups[1]]; // Loop over every BN - int iprime=0; + for (j=0; j<7; j++) { // Set of results pointer to correct BN address @@ -432,7 +432,7 @@ void nrLDPC_cnProc_BG1_generator_AVX2(uint16_t Z,int R) //p_cnProcBufRes = (__m256i*) &cnProcBufRes[lut_startAddrCnGroups[1]]; // Loop over every BN - int iprime=0; + for (j=0; j<8; j++) { // Set of results pointer to correct BN address @@ -502,7 +502,7 @@ void nrLDPC_cnProc_BG1_generator_AVX2(uint16_t Z,int R) //p_cnProcBufRes = (__m256i*) &cnProcBufRes[lut_startAddrCnGroups[1]]; // Loop over every BN - int iprime=0; + for (j=0; j<9; j++) { // Set of results pointer to correct BN address @@ -572,7 +572,7 @@ void nrLDPC_cnProc_BG1_generator_AVX2(uint16_t Z,int R) //p_cnProcBufRes = (__m256i*) &cnProcBufRes[lut_startAddrCnGroups[1]]; // Loop over every BN - int iprime=0; + for (j=0; j<10; j++) { // Set of results pointer to correct BN address @@ -645,7 +645,7 @@ void nrLDPC_cnProc_BG1_generator_AVX2(uint16_t Z,int R) //p_cnProcBufRes = (__m256i*) &cnProcBufRes[lut_startAddrCnGroups[1]]; // Loop over every BN - int iprime=0; + for (j=0; j<19; j++) { // Set of results pointer to correct BN address diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx2/cnProc_gen_avx2.h b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx2/cnProc_gen_avx2.h deleted file mode 100644 index 2c8f21e455..0000000000 --- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx2/cnProc_gen_avx2.h +++ /dev/null @@ -1,6 +0,0 @@ -#ifndef NRLDPC_CN_GEN -#define NRLDPC_CN_GEN - -void nrLDPC_cnProc_BG1_generator_AVX2(uint16_t Z,int R); - -#endif diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx2/main.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx2/main.c index 7cc0fdce11..d32e549cd3 100644 --- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx2/main.c +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx2/main.c @@ -2,16 +2,18 @@ #include #include "../../nrLDPC_types.h" #include "../../nrLDPC_init.h" - #include "../../nrLDPC_bnProc.h" -#include "cnProc_gen_avx2.h" - -int main(int argc, char *argv []) +#define NB_Z 51 +void nrLDPC_cnProc_BG1_generator_AVX2(uint16_t,int); +int main() { - - // Z=384, R=1/3 - nrLDPC_cnProc_BG1_generator_AVX2(384,0); + uint16_t Z[NB_Z]={2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,18,20,22,24,26,28,30,32,36,40,44,48,52,56,60,64,72,80,88,96,104,112,120,128,144,160,176,192,208,224,240,256,288,320,352,384}; + for(int i=0; i*C!Ia%?EBK$_k9mb5=fxgA?$0y76@WM76k_}5Q4-2q9`D42qNf+ zfFmNP$fChzR9pwwLB|Df8C1q$7Ki`uSLfY+?{)fhzsC8#|Nr~`Q{C^@y|?OAojT{# zxmBmmt^3yXhaS+7=UEXNvVAkJZtAfn-HKzDHUFj|U3*xQt;l+FoRUqtzYJ>4(jb4z&KR*DNaFNK>?f}2r-E8=IOxU7ha_SrUn$CS!DreO_NUav9A z)}>=PHm~8xUtMyR=W`B=g6ABzHr+4cz0*~e6>$M~6ma5MZx~q0xS>>EExNo^YF`nT zF0=XPZ#iSxlKJPKHTV22TQ9wA?qw^M&0V%+-o+QpTa?;u`Q|g+-MK~zBTSE2kqt0;Ln+|V_A0bg%@qvddcQ&^92{4y*0b= z(n~JRHg3H5lGD$8-NrM|eci^*r*AnwJN=9cF1jS!eCGKVTzq!6`ArvXxrC?$w{fFo z331US8()9=maTxF^ZE<6mhNoK4m|Xr{r2CuXx@_6vqkfyYeV|$R*H*j5(qhWQ} zL$_?{uSA?*x_9a5ExmY&<>1%6QSoyfJc9-0#V`)kBdRB>P47olbQ?|QZD zYTW0fiCN2z$1iDo{&S?XZ2wZPry|FzOBa#!>eMA1ncI*OK6cZRz?yPvqLBzi?r? z{*%|T?1fF~`bDoL!3#&G>x;PFd=u9xEd2dJJHLHe%g$f4Z2#p;M;>#~(~rM2XHC}f z^b^}s^z^ko*JRJX3BZ>(H%*{3e)g>p>e!aKml3sWe`P?+&R@N8%x5i1@(eolizdAK z9GS04<)8YLRM|YQxPHv^V_UBJLn`2j|LH~nEjwRodE)uiE&1-2Z~xCF!&*!0Ta?x` zAv^V{sDIl&E5SdzbkMN?KED;jPTk!&ja&JjQ%zrN=7G_&eRXze<8N;UuC=f~3h?SP zr@ruJU_6J3+s9!gm4%OQetP{)4H?IGb@TY{?jCPx^mtnjkGJ>q`2JoV zKiJ#j9eq6B+1KMo`g#0le~O&))6 zuE%FD^!TI8JpN>x$DiHg@wq!Z{^9|TzkJ-|ub=Vw{Bs^(e97bQvYg`|nmxX>#^awh zd3URqo0efZVL(l%_tFLa}x#K59Z8+5O^o|Ap_3EpS zuUm_Z?pVR;Q*pY6)7_kI|AN5TWxeC1;mWbQc6ev!?k|3o4g$N*~D{sp7#(xxvCAocm) zmj1E{yCQw(6Oa1%eM}|r#c^iYEOa?_L~H6IQ(LN27qzAyY3i(6sn?m>uR3*cE9~Q@ z{-GMH39YHGnEFh0s_HRt9(e$%pQ=t(gGK6OQ{PQ$Eow$XADcnGR)Q|Ew5NCUB3iS$ zm2H>y=iV!D;5P34_W0mo-g@_5@2)Lzw)O63y*s;=&6iP4Fzo?ZSy1`u=da@O`BN(I zJ@M$6)>hnPE51qU?i~X`s>kjfgNXX=-Z7Xc+r48*Tn&w@VMIMz%YNd~C9UN=U^&-T z*HTV>-qdreQql5PIZhFB73f>Kd(+LGwBXfpNiByDRKV}Nm{1D zv*d22->J2rD(Lsj4M*nflCZfNp*AF3RGr#}ghM;1xFBK8itqXNj;Q!Zb!rz z5vK9GcT6POd-sk>L?`XuF`0-CJ|%8WjhoZr=5!(eX2i{zadTGOoK3WMsb98ie>^Ys z)}{2Y>btdjEYG`6d+f7x>oz@>2DM7uZ~v{e$AU!n=(SJmdXH3T+4)RM{&-8y@%fgy z&oQV3M>^9DL)#a?4@Fru`tXC*sci)CW>TNt@jJT)je6lW4p2eHm(kk2>jpElgIxZV zYWxb_`dF2YdG+Ng7Psl`gR1dsBd31`c6;Er{R?7&$eheju+$UP9&KdziKwl*357oF zPzxMijb|I--I6eoKPBPq)^zQd|Ea>HEWB4Lyvu>u{Pd0^A?EoE$aZYt8@_;8NaFUsHQjzDBBF||>o=rubGdM{Fo>k=8T;w^o$a7wi=X_35rCWl88{S_nWxsdJ34>Kxv!-8r0QclJ1YqT|l-%|9iwmRQ)U`jPhVHD8vZ zj91Ibyh_||3g{Z$;m+#RHr?SGQY*T{JF2=v36UpuC3!4$hbMl~Ku>LY_?q=4tZMbr z|M+8-thDI`eXG%G(+hqNY*jBn_Ri|C7kn;iYoCN2_JX6T@xPsA}1;H?>I@B9g^Q9)JvSC%zxq}Wqz5Hl=&~5q|C2yk~04%Cy!S=X1bO7 z*Rrbq<=xu-OB+FF{p*Jv_ph!0TG_w)?eXw=;yGnHJ%e}vt?>c$F#k0lK;xsl8a-}7 zb!wX)H<;9l9`~NA9#=wbj|WhJ;8*N-N>)Oy{in}Wf9R;+-CUj8rr%vkYE{2O+E44S z-|ZjemHJ%?|GJ(&Km2_ao^75!za_P5=+xMB?dV$l?o0N&M}R;+k7Q=4d18kXXYCF< zj^X4aPmbe6%fgNmIJw1>lQ{XbC#P_dg!wd164WM664V)-B&f4ENl;FU6V$n!B&hQ^ zNtK?@NrKwSNrJkNlLU1UCkg5jP7>4`IZ05Lagr*1Gbah^3QiK#m7FA~ZJZ>it2s$f z&g~P_wVb3%uj3>^y`7T;bv-8u>PAiy)J>cusCRLapx(_%s`M6464Y&+B&gdtNl@?S zBtdwVR!ZF>1TNUiGS^sQ4m?B%CMd8J-nYC&DS{Le2`;n}8_HzrIfo~}Kbt{qvcmp^AO z|1Rb2-mwi8h|S|FqLI6ITun4(_m1sE3wH0ghG@m^9Xp6xcJH{B=$PF*-bTda={h0+ zb`k;bb|L_F5dm;L5db$30dOM`0Pi58qML{Scqb76?;--=W+DLIO$5Muhyb{S2!LCO zsOUB#0NzUk!0ki;ypITg_Y(o|0U`iCNCd!#h^XieA^<*21i+m{0Nh0cz(T(cw?7PHofS_aU{S!@swx!dqr;c6b6Q!6VEYgDdw-o; zTOin`%RgG3+NR6DpVX=@Pe(hc!!CbblvnEVr8d;n<+Ex`T*?b`)_>c92PaG_x_r;3 zYe&`U^8F76;<;bh>b2?j5~|kZG;m z!1W;lt}hXATA_jKPXycmBH)^cfE!2z+#n*V9ZUq=5F+4)5&<`i2)N-yz>OdRZX^+K zqlkbTO+>Y0h=3bQ1l%|x;KmaHH-QMaW+LDw5&<`f2)M~aR6B(TxT!?IO(OzsIuUR) zh=7|(1e{iP;ARs6H;0I7=Mn)oj|jN=M8GW|0&XD@aEpk5TTBGp5+dN15>f3kBH)%2 z0k?t(xRpe}ts(+$FCyUfCIW6BBH;EVqT1C&z^x$yZY>dT`w;=RKM`>2h=5y91l$2c zz#T|*Oj*VBD5;o9RVv22f18T=a>puW@xOpftBM&}JvIN#HD6XNYukPQ?H38U=(250 zr9GqUBDIZ9c>&l8opN)PPAMVMc52?OC4bSG%-pO~b$3!VYHhU1`PHdyw8`P5R%sLZ zu&cNbs%T6bBh}a_ucS@dkg>z*`KNwfRc@OB#Ft2|nkMvWx^`Z*HW}Nhe`cyp-US2? zJlMwC$%8~l1mQ$!%~B_hDTOa%CDBEX*}0{kmPfPa+;@UIa8 z{&gb2|B(prZxDgRH;DlM77^gj5CQ&eBEY{x1o(G}0RJ8l;NK?#{0BsU{}T~NJWB-l z4~YQ(5fR`&CIb8?M1cR42=Jc~0shZKfImkB_|J(z;ul1K{|gb|za#?uS44pSnh5aU z5CQ%?5#TQn0sbNp;J+mTiQf?c{(B<8|3C!zzY+od5)t5kBm(?TM1cR92=JGQ0RJ~4 zkoXG`;Qvkp_$x$!{|6D^|49V+e-Q!x-$a1_l?d?vAp-nWB9O?i+5?^w0p36acsC-z zyAzSKkqGb}M1c2^P>)jOQWN(qQAFMZF8zq+o-kyq*kc5>fureuXcw^ft|ypN(9>c(ze+|3Ye&g6qAwh5Y2a1r?wHzi%G2z z&Fb}`5^gm`vzWU}`wr&r|NNsWj<=D_KUSxz!xax;OUd z*{gRS{XY$P7&R{9s+FX0TNcY?@er(Uay}S47*Q;m0KK=Uk>Di}G|DL`2 z_G|1>a#HNqw|iqFl{I$jLEzZfgPMDE>sBH|WA|?Dg@%R(G3?c+$I#xOk@f275#n)7 zVfctXjg13(_V3ZF_rTu$vTVS>hVI>a^yoz;{TuNH?9tfJty}l>N3#OP<1Ct%H+1io zlh%e(xsC3fH+Jjk$^h9swhei=VeKcBGEO7LzddiDG%`jR6%d1IL*5uSTGJ~k>DH~W z8?YUR)g-TnmxuB@jo)?rKEb_5`Td3S>3O#80t(sA@4n6o>$s}+Qn#^`wawZ0bbc#2 ze?7m4INu$)w^8Lby{ESDyCCjW99M5!lkErohip3{J1RSV+sWHb&(7R-Rz;2uPpQ3W z+wg46wyE0|X83neTaRs16D|cDIAtyTjw1DBe&_JJn%_J5-NpTf`TZlmU-D~w4fL@; z>9CD3fkWa!YU`z(%Zm??RuQ(*X`~r1Fl3qI8F<%0Sefm;ZJ!J(ZQDOvzwLmmW!pi} z3SQR;W44XmHX)n1ZALb0+w5%aHXl3$YV8e|hGiq;I*tfshoLfWd*^TMB(w)pd9TCD z>qx9D>$RMBf_|sTAuZuc&QO-nklrikmb!ZHbl#V@Rn(N`4SiqacR8XVvupHAsY5fL zeIv8s93y{Ydi$eSO6{NCJc<0{Gd1v7P)!a(`rI=US7| z6|!+D|D0?p=LcnTIj&0hY)+}OvdC}eSd)D>@ zOcn4#_6?37NOum+y;B{6CasDQ@Sv!1oK@#(mnWmn_9qC$M@cjVmqEn{OEuF=^ z&P!+{clT1AJrcJYplBn1_2FOC(4#mh#XREL+-d((nd?dYjU1Jg9;qe0z@$fOi`s{b zyFJO(2iSfb#k>!{-jviYop%ITqz#~ie*EbJjZRmD-)BR{L&OFUpac(z5f=k9PK@1Y6M`ETlq@M33mR zot2&Y9tgG%CT$wkKUptlz&oQYRW@j;^-_Ck}v=J02BNdGW2j~@O_}0vM&Fn zSMa|H>eb8tQHlQpDPasy!T-^eIh;G4hv5Ghs8$^svdPsqYFx?x89+}f@qcVc!z4n4K+RK+~K0$Aj0zPN75c)f&>h zACUbM|NC&=y9@kR*5!YHo}ZTGv$3Hr`IrCA*=UAE<5K=nyzw~_+E1;M|1;=0_Wyyv zkAZfR!Mg|L&47yI>S(`D+ziN(=}BG&sGtAK6aP2x-t6AlKH1UP{_x}2Y(BEMSGl;F zXJ=#^pxa*AVbtG{9aF*oRayP~-wgjR1o|BKe^H752WF?%thJml3Tlmm`orM=SRltC zzYU2W_40ol(mIIYenU11t`+@m%2A)hu6vf7GSIS?^LB;{-2z^Bijb;H)OZ8^8Xb0|F$mi|1QRA z*HdS~|F_W>@60rpb{6hV{r_j#gW2;;q0Y%Zp7{S^`hQpXKcj;GtKdiPswrG8JQ|SP zBTD?=kodne_5b?$|MtZHv*A_~qh0xbQ+6>WUCCeP;hDt$i+IE4hU}@t|I4#aW^eBj z|DT2b_tO7v;?Gd%Av!UN*b@spSWV7<->=(ck^#5hHAip^Ka-H-ag^}R{ z)cGFp|4Fu!^INkg!T&v+-_u#+Nq;iyp9lU=R^h)Q|507~!z#)n{W$Yj`Ija|rCjaj z$V-?;YPrnHQmXS*rj*Ms@|23JJ1XW%!p98C*mC2_V_bR1G~=i(V2e9Zf_eQ5D9_>! zQMw;-0qMO6MO?b9BXZOqwFCx&h;7UTx-$+c=5@Z^9erdg zVm@x0go|2=(u-M3z;xwkS(fSC(fNksSZ6cND;qf%BZK2%XLQzVK2rn26x$gXnNplN z60*b?SxX=BwKhu+Dp`|ti-EPgmf&c+5;A5!!OQl>@WGK@?T+t4Cd?7J#HUOH`PY+? zLJ#mQWTmLVTt!Zy>I=>{x+e-aZi_jD6z#@HNcu}H>D)j*XD7DPnTaxuK`m7hJPQt) zVu`&-a}IBNFdqM|aZHXlsTd(+g?r2&Ilc{|; zch2YCe&lfUZ*JQeGbnNC%e@BD#ngO`&YdHLKIj3AGya^TG9~T$a@}?MOXYry+of+K zaeqp)?!J`Whgy4bW}0`*)jf^yv^Ury_hOK;w#=Ehy`n#{?dZv0pL92RQ_oa(4utar zWkr5wT#1A8Hep{&P%5QglqnsRj?gEjMKAWc(0<;HJdw+k0-jSsk0BL>Qf2=7dhWMT}98Z99z>3-up9Gk0d$Dj(L?md%68D>}X&sQ4{|8g5dTa>wY2oY7wbrxH|NVjL zY8Xse-N9PD7;;+Ze>G{L{|94@DD?jb&bu?q9zu)M|0BRR^#4Gxv6Nnvrw(o+eOPLl zvGBu5ZQ`#7E$_!~0M-vJjl;P!lIyP1e-v~Z105PD!&M7u(>K+hQ?|JFrTm`hj=6>~ zPq1!h%r3i?_5T=h4k2wUGmlXT*WtwdxEf3yLnvb`M|c-a_QmH z)nJdb-O|wBXdhHddaia+dQ6X}kXk$Xr1D~_QXS(lOY%(Fw~Qz`bZ_)_Yq3=Am7#yF z!Sbxza=IGCS{XK0oB5no0z%iRWgH8LLukpItKQu6DXrcL?Q3pR)a`0m^^(u;2GWhi zSluR`G4^oO66<2-30)yCx*7%nt-f^hA?9*ZnkYpL$Y(EpmfOV7{#EFI`~499!eVQW z?T@6}KL^nksi3}5N}_)bB(HtkcBm_~H`;&yR{cMU5_06c(ElSTcQmp%8VvezztI1q z!ChT4n4X}PQl_<04+Agzvy|-(hQp9<@oV5r+0V$Ob{Nh*_5Y}Zx%z(~d9?ZuNp&~S zn}m2RVH7}>YXyTSv#kFIQ*$}^60_@+8MyguFxZca5c)sXKZ|?AN+*qA*bSUVgYh`( z7|dVBwL$$aZMqsN_5XAzI~y8={%LiEYX-R{K}q%hL~0&M-p0hm z861_S@nAF(94C`Ll@hdUjsi|eoy`3yP~ZAO|I6K8-0!;npM%XQ^#2S>wEq_Re>zu{ z`hOaDH&gFIWMMqVxvb*$L*s@1AI;f7QZ1#>|1(J+hHbx*)rI-|#<0#j7Tf+zY8lG) zP;xJ(U9-90Ol#*QDeM{tLjTVOehIc?=|6<>7el2yTb?Zi*S^#p`rlmY|3%=nl68hL zv?KKY1Tb1j&V}H#3i()$j4c6n6xfdjyUC>VBt`u{jk~x-aCZVNV@EdrhNjhv*QWoS z2if}^J*q`~LWcf#M5R_5KzcEcQXi^s)%0pqM+4pXsly8W?_A4KX?IF8t+A9#ZRSYC z=dUXz%6tSzQgG|J6T^XF~s5&tUY1x^EEYK7rMM8Mbl+lChfvF^CG{Z;<9r0TAzpG6?|A$j{AI{YO6S$g$yiS6< z>i_XzsI-se{!nV4MxG(`&7Mfq7}C}M)5vLW9S!tQTC4saiPUu`%|5Fp7(q@!2YLg@c} z(lhgDWZ-!Amfai5&Cd=cR{tM?dsYvQ?n~?VKlJ|!QbPY9hE%U3ulj!xx@3R2*pwX% zA1d|#QZQEk%hw~4EX~7K-=Ay87YD%IUflm%^#3XFyi)(4%vI?BRZ#t4IIaFa0WKH% ze^a&w={f}7xnimQKLHFw|F7oWsiYs2okq*1WoPmmgWu3t?w(58(Cj3Bry#jUp-sPqyH#YT*gpBGiz9jsO=o6FcT+1_5a05{~uVT|Brx-<*|Bp^{lAfv{n7tNAU$WWI(823dFKPQ7QUUu-`}GD)hX&VXAl#>u7P7& z|BnEx0r0yQKP_F(G6&M)(Ep~Y|HnaBXCWhya6Kr>`rqfBvoUjxC&g7|pLQ{xP|K+^ ztUt=?8ufKs9Le7Z;zIvVhSSYR%uIgj|7L2RnRJ~km`dKz|MQXOiS)bC^waU==ntR9 z0?~~Y3+fjMA1 z1dT8Xt+qcUjw7W3Z8MP+wc9X86Y62dgIx2rDZI$Ey&Uyb~_j&>w69{T?@dRB&{ zE(4E3|DTRDAB-f=Mg9*%mP7xqK$_1&u9qU=YmxPZv{e0n5NCUnC-nbO>B+T@(g#8j z_5UGAlQXr~rvFNlc=S1?)d+Fu$=<6&oA98^#2>6 z^Ym;-yZZl9Qm%Xr`u|)wd=9IHo3qoizh@Ql{-poUVmN;v;sq~|Nhl=}ZJ+IMw!4Q+cI{LcgLw;+i$4ld`o?TK@->#bq5q#m+E2;empzj7|L1AjYt#Ra&|mMOk3Em?fcpRG?8Dh_ zkk89Y`u~gcthYkV?dd7;G`!jhuD@rM{aeWY=d&-6`dxUh{{I+lQvcu2D)1-3_?>C| ze{c3r^nuT1pQ7xC!15c^qW=Fb{p8b0|6iZR|8L3O-Bt3Fe^33t8oi(cx?_^E{$I?! zIrPGX=!(5aX{0}!s?X3kWNj8WjG*_bo93X^XCfm_X?~^tHTR=JV|7K*VtD(^U??S&!LT(?&e`W*6pP_pk|9>;-|F35s%^sl7_NAXL z%)ZU<(d<6-lKTIjXpc|bdy(evWj{oMzC*8FMK7w<|JOq6cjFgv6usplQvQzqIvyX1 zTj&?+|BKK*AEw5xh8B9zHvk%v3wcul|1$mT+3d08KjirT3+b+hPlNGI$&Z}zQeNo) zKa*1E|MzkJ-?X+;|KBYrA+asa|t8rrO4Z5=$`|V{yCyU{c|}jn1C+5?0-rB zddses7l}=cgjm*Pu_-KVMAx=jNn;?&n$HsAdb#_1m*u z$oE}I|6E4TFYBKz;2!#C3%&o|*PwqM%>IKX&466{!^!aUJ3Pfc$CIgB9{T5(*^6kK zMcMRxD-y6IACWD|)ju=x4`%L@<`>e!dl(07NvZci*$?m>{&;o?y6B-KKc7GY%wz=hE#yb@yY5uglQ{A4>9b7l>NZeVrrRCP(r7`WadyFqoZm}I8}vH86d-_NWhk!VJkrYd%h%p3?psAs!k*QcODjO}7k&ojZ%99n z!W$QPBDF{<(k*4rpvBLeu3{AD+98Uy_->@>15ngx33289@H8-w>E>%2x~ChFVm@=Z z8r6d{*TllYp%pHC4N{hLKQPiqLA;`Ed#;aJPJGd$z}fc1nsR}sImArpph~329a9Z~ zU7VMXg@1+~DZMB`n{QZov~{{_7T#FaUaai7nr3^fP264c*1GJ<)}Fy~^uzIe1#QMb zRqeUjl!7a+^IMM=<5)!xFSBTAzm#H4L5<2fT(k4fbz%QvebX}ZcX0hHEZW)xOp7;w zv`CxR@?6^+03KR>`&Sm7&V%o^wcx&Yq`aIBo(5%u8}c*!PJ*&!39^LXPGu!gQo;YA zPLvSzwFV``t8y+WA9NBTygcO9p1~DRxgu<_8mhlV@HM1WE(jagSx%HB4TY6*-YF=+ zX={k}FxL-UKQ*_$A#%H|{JV;3F8`#2J_UXGh5Uk4gyKJwb6d~;A4F?MyryUMJw zK`C=3HSjUr6z>#a&$3NXay$-8^$!H5kbh_OzBMDIUFp!e8Y|n%zpIn3;JPL;Al-LW z%JE*?;JR*E{zK!nm$p%Dn> zUwfBpf6`(^N*l}3bJtHo{$2YUKpy3PPyYfbY)P@=Z`;H;q*kvs*HH@jmrjNJ2bb-! z@~qH|d*W|NY7Tu3?1QchD0jxfy85oxP$!8)t^ECp8UI-Z7FhpBtPF?9nD`4?z?(F5Lh{E-6K=3 zVU();>+>>--yl*4r#ke3X&XW+LjK1xE>r%;Q9{VS>)5e6;d??M|H@#o<{a`LQrV9j zdj{p-b+6g9a6BVhEyTUJGd#6Lo4kH3zN_L|k8k6;LZ!uhBy<|dIBYZ}XdfP5L;j~= z0VvD=Z01I;(JKG04k=AqN0t9MjMEGGw+?g8qx{7wWjr|U$=?~YO8MUlI%*4UNI6iSrB7oQppSXSBtsM z>nf?zsHcfuNXq2^@)h#0rM+$NtxVVdluk9A657Q1F!CxxA^!s@Uu~pCKrbi#qQcui z2qnxl*t{JMPlq>ys6pABPF~0MV<^{kQRQE)p!_Sj{h)?xd0zR}T{m)0CI47*D*vvi zwhgXe>oL)bIsZt0uBa{JuLt*sU=X9UG5jYhP%*2`obX*O8}?|HG5~A5X50)ZR9n#oS;uf4(7i7<69C??Q5(51t|a z$6ztt8{QwyUGFqvDN_H>C$I8DhYu4lmakpIQx9gj54 zPV&EZ;`GcU|1+x#=jtfrd2&zyZv z`Tq$Ne3(Bi6<>Su>rgpi~8-%_s_$w_o3|T+-=}aWA-)qrERxh zpSy|{dG1X z{`aEZ_T~R{>{e@7p*Vt;-iY1!=Iq*%{9gto=3-mfjug(oPPG;EE~eBQIJ+9_qWb@O z@Ov9A?t=_p-WGjuyB*w~PV)bFlK+nYtNee5Qa_O7|0}F|2>TPT_#xKT)zrEho5Z5* ziIV(33jD+H>54td{|&aQ_hR{FypylNz7z6)E3xvg9k(q1eey#7|A-a$CV12*SN`uz zcHdvNBb`~cJbw&q%kuwUSiydojnB6t9li38Q|qDmzhnPY{!hyP1NlEBzXU5%L;fvj$~ezUoHp5*6hR+2u)*?CyM-i4j_t|UL3v1k?Ya~qtv4hg&%d*esp^dhWY!)Vo~ zsPW;F{G47xe)7CKw4a+Fkxk6!VfVY44ZI$Ls`qCj^ZB{*GdVBh=Z=#649Ks}#^j$v ze&#^W>3PV{C^%Fd9&Dx0tyn5A%wB;WAHmvn5Gx4M=hjyG{1E#5j{a@`dLK6A`N)^_ zxgGA_oIQsg`Fre}ZNthO8vwXSpKtIk=Y!b>aK0=1J}Vc}r%!JG8kwJv_sU!H--7+b zd@~leKV`?}-_MTDFCzU-d3SWnUQq7Ew#8Rn+qn3}3_6ZsEhwK0;?*9cs4A;`;T*`^ z4e3^KRm|2c%M|ZNn%Uw`0_fyWSa7r>7`pQ-Y*y(8_XAUp&SV0Y;%?-reRO^$Hd=oy zTYNni-juMBc^%d(b9v?{yPn{T(BSx341Gcbb)AVi|BM`#X^GZpOPxp76P#fN<%QN- zq4lIO-7PSbhS~%o*cQk0LC?`j+#PV!tznrz~orLkB)1wG;M?agmI3iY-n>Z1Z|9idUD#fNwIo@ zd@JN%yOq`@i|#Zt`Wb3LIaql=iAhMiOS*LD#SsNKpOVH>kW&M4z; zpOCB0>d-P4R#ELDz89p|mGZBjuX_v0ecwV<14%l}9)7)71V1v?Le7=MNQk4_X9dK`5X@^2}6Mh>J*<$pNozA049SvspB zEVEKwszk4p%i7koX&Jm$rj!GzVlMSwJ;A;xwWDuI8zna0j@6zXwl6JZS|gP(rK^7V z?+2ZG)8>$WEe~38ee*?Ig;tr+4I%%&%jFwp&ZX;*pqx@ULbXwF5R`uaO6PS>Hy|;%lrVaVmE-{X= z&p>|K6RYKaF*Mbx)p;1i=v?`qP8kzuNu~VH08eculbK66mz-85|IU0m524-k$aj?{ zRsf`VBlzb~$e=Au`B&p;D>GNuUacV31O`^KKO4fjEE_o=SP|9I-q%YP}@DgO(=*S)BQFkcM$ zp9uzfI4?%R<}tDzKx%#RQcznPEb@;}cHZ*$Yl9|6vnL89F$q|HskRkpEdg zyQ-syvi{F=k^dQ-jpy!seuezIzuUMDN-ZZT|Lft_dP>f){_KTDn2*%-hQoVvehA#& zhqx^Nhhh)XYie=1kPglUVWCj|PlBRLnfb4#o^zr7NH{zM4k-UeFteIQKIQ*(+IkNB znGN^r3Ch1YM?;HB`9F)<;&f>9cS-)wr_Pg@yJyI%@_#0EuBoSZu)Ci!)a&OUpEH?V zeYn4vC5g5KXo{!gZ@hvOMkPk1NxJ@x;6CHemvR~J&^*YOiQ3J zQHoE+ImrAh=+TU{Pj8j~X0GMB`az$1cLQ7nPo~x>Kg$1Mv{lRPVtBYB$-f>_W%)lb z$^S;AbT8^3On*NZY8_S&`N>zv{|WT^L-6srx*hqyI?4YQq;({`y%qUCqfY#l{~Js4 ze>bvpKNg^K@eRHX-y;2$mH#iokz3g5N%{XaHi>iKO}+B}F)TPgr==gqu9jnyd6e_p zDe2|xuh?}yoAu3ah3d-xi`gGYTZeV!tN2QFRsJ6UtG{Bs+b=&Qe-8bBBYuuecoqGo zB>#FaKLF()fYW{R`sM!=DA^1*%ks0SBtM5^ftx^DGq#?PpYv$RA+$vKIlE5!_a^6I zV5|Jx40V*BE8xi|v7!&g&UpbfpGY4(11>DWuCyF`-kn{PpI?Fhujs!=vd8f3d{X`` zc>A#`{i*zX7~B6pz>!0-IWEC|SfBp<37Fl1txEd5C-tvQ=z@FbU*AmhxuZm%duZW{ z74-QPb=4CJ`uq|49GyRk{jDL}J0F}&pYLRc2pSI|LULD zQ@$39u*}4nFvXn$-Y00-3$z);RgpXF2Htb-r1eP)fM*fHw%{x*>;qw=ihT$ohb1`{ z4BM5tv~h&R$Qh2aVSlE$nrd$C`7wTUrQSFAiya6Yg*YQ~Bxew_ct6E4fGrDLi@0dN zrCXNwtv$|*`Czo)8Dz}!!pcTA@;SCGY+Pbz&Egv&{1lw~#ZE~@`}K1&2vM|OKa{rZ z_lxxer9yF*E=58Fn^{ew(Sd4p@x z-I<8?F|Ccx)Qa|NrE^}OjY=Dv^WA8(zA##)Y^SqSEd{o}7(MxRn0w6H{*k1(+p~TS z<@UQ`=%~zHV{L!v@&OSp1n)%H)ObVvGnSWHYg=7O8=#JO+!{+vx?^wTpzSGIo@dUYf@j;H;Hqa6=! zZU0edwX=Bc+Wxih;v7m^2?bhO`EUC#Zf*Zb)W0|F-(KpHKVe(4Ki!?Oy`si}*Vn9XAvH`#z>)JA>`ti}oK!`;Vmk2c-5NL%tJJ`lY4z zxA0uwMfMkf0Sp_2J$|h;PomvpIZ0Bf8d;i|KU*L3R+z7 zPy9D?-3!Wz|L1Ajjja4#oZ!WON-qAB@_q4D{wga}ee>D8fiN;R!#61Zca;Am<^P6p z&sezpclb&d^pEGO z^sH}%LCC^yG58mpR5O)F8Dy#vf>QB3i)Xd`_i5%+qIgQz0Oq!<57Jv~eX?sAa6BR{ z!t1d%tSP~N?Q1cn5nAuk;D6^f+DiV12bs@LpYD33b%p;;=tzCjoFfJQ`Ns1|hj-6a9it$BwsMlj**UL2cAD(-z1j!3WDfka`gnCLV z`0v=rZ=1xv3OF0s< z|95T!^8FNZ`QCnCptWuX|3{#eJBOF{j!t|ZbP<$W!1GZ4PeU@N*TsMLdkFq($!Z2> z496w>y2Ah12Tx8qz8V0mI}$|i=!kwkd-c*)bGgULP+~3n@~=MryZ=FVV5acv0oLy8 zGA6-Kri9LdyO3xN$)VdYo}NA7-r~gnrIf05zT;5M|9u%-%%z0A6aS|$V(Bc5$0BeL znf5F3{}^iBH`CKn{+rTqDEPlu;{Q_ke|m}kd*jixzGGlg^~nqVAICWBY(_tW7=@k! z|4)IQ$94+u?ofJbjwQEimCj}4|2Y2CM4bi4`h$@A9I7?J2j74$_&<@kKxbhg^~nFF ziU0E$XB`Or#xRy%&X{sxXW)!<3;v%?Ia{!FoCyC90`u2X>Uo{QABm(n-x|f6VkhC( z75u*js<=Nv=lp*ow#I|7UEGe}-_jL?R>eE}rN1fJxBy*LUun2vug8vUPW4JZ(|J$9yPs@Y<2j^4sO8$?{@l4B)$~!Ay zIkSSG|Lc?2;w2UIKN`8}EF6a=F6e(1t=Lhb{{={Oee|E0e*wC^jMtv@AD=%@%je~N zbLszEtf`%ahZFwJI|Bcg;hy^A14zMl@hl?39}V#%hy&_*vHyyf278nKCTVy+5Xsr*!e`q z?bo+qKsEAQIUbAl`^}y`+wYrMw%@g9$69-~Uwc@8o&c^Ex7U8>JB}|4YhN`A;d|le zQyZkSs_Nhv#c{IlYuWy`Ezl3%{T8GB?)q3Ad|Ei;akOpwOzV z56|#n=oH(Jzw93E9|(5t{wM#PAB7dJT!}mKIFg^9HS;%Qk97B(T*Mf|w?=IL!DY~N zHj&l5?%;3=C9IWn{?a%->vQc^&ag%C71szSmToatMKx!4i_f;kH+FPh5FyXn5#Nm z%(~0nCHx-%|BqKE;|VSPzhQrct*oH@+aCBw`QN4dk5K*}_b7jHUX=e_c459}`E9Bz zU8-s0uXuK-r~MVz#aY}h=Z^c4w@52s$|V-iky4c1HjYxvTMp$iJkxp;u{q)iSguW7 zXu8Mp-MB96NuMeHnWM-Z&zZiWMp}TPeDnD; zn8%!9Niq%_Rbel*WO4L5Rz(6QO9C93My&y()t)d99*OD7v6u-F7x>O)x*&{<|r(c;#?iHVQGyr2T*O|AI+hXN@W2j!TB7YThqSf@dKAZK%#}Uc zEA?Z1B(u?SMEL0N28W< z`B7fM**)=7^1T~9AWD-9!pR@giX3vpJLdAP`J!donuRIa=(UmsA7Nv%? zMtjMSYBMeeOH_(1L&=LC80*S~@8tW71!v&VQ;nnSa$TQLjQR; zI2#;|a+HpsTpY>L8XQCVMua?3vnVyLhk93L`z!TdKWdcnwzAMe1!wo9pS`otf6~LA+60{X!o3R${TIDeI>Z~wa!L~-D?$kA}leafX; zS^v4`!)RKqck&og{bGo_C^T_bjpNr@M{*tdZ#egTuIe3cO87eHq2aEvW&P(a*-DkW zM`X!nU5kE&{tJ&4b(b2%UJ*Z!@g!HGqeq6G3EiV?yTVfZ?9tJ4)k?~vBM_-+zpx)$ zUX*R`4viiftdPP=GKz=r(Ra)GPYx-YrdgUfl&a$C8+^A!pAhODrPwta#~99n?eE$s zLf`mokEdUh6@AuqHp>WY(;j}sDuQ#xvi=L55k4+@oyP7B?yK!y46gMT`p+H|xJV;c zC1OVq-&9Zo`COA9)+4@3o;^#9{Pu)jILKYM8R1gjo!{YdTSn-t?X7W!`tHATzA#;tu{?%9fJ{pY%u(iXc| z6#CB{@|7c@YvDJZIl7WFp1fi@nHr~Z?jGdRXy*j*a*e??wH#}MyP(XVuJPmz{pY@? zzFVQ?A@=5X{~dSQa8G0JO{G;cfYxipHK7SfBHT}TV&bo**TPS2<}N;tm!?vuy?q$@ z4Q2heFkNeTG5CIgRPw7Bq5t$lcRg+qamM<>WRC9kqh6E(GrUdiO8qwhzo)_mq5r0k%Tm;Tav}8J zOiG;!b`xpy45VZV5bgrwzSncP>PcB*%E}C+O1Ls>UyNs>@5RM_;_4Q4hhLVm z59*&E`p=PtU*|EO`Z{!=t3$3Z*;_;Z>F4iLINrh&`(>#R~rqj~F zH>$Lj8f%gBnV=3(ZiiBWBM|qUVh2;&YC8(6qHhzp>Z#Uo?;EAqejNJG{xFad^qPw& znQyGPGnalv_D9#N{pyfDT0$A(m`+QFiEz$+hYI~S0zN1+epw@fJHkxk+;7GBm5R`R z+TIMl0i?Y9<&B}~Ip{j6d0eYj|LHI1`q@OTMpBbF_eed)J!rIoX|MBbF2kPqEvIiy z2YMh9;Wu!maWw%cn~Z&{tpDcH&bg$z|AM##^^tom;bv{%#3LZbJfWtIAG z73;R+u-Y|%zdnSk!EjEZaiRZKQj$G;3jB8b=aplZYW*j4o_gd=N>Tq!sfpis{I3?# zR=>Do&+{7(Q#sd%zO4TilS}<~I2NtYe+L7#4<+Y7jK}Nl5OPfCjRn8gto~a{3F^P2 zxi^&+#u;Fu{yTzuhd?>M*YmgPze6c2#sQt_zoW_LdUT=xj_10p|Bl64YH+9hEL#J9 z_Q10K+Yel81$Ql356xc3YF(lKwj}*`HYNDoiC(14h7PB&!n$8c|82rbx`I177EH%~ zo5-~uTkCM@c9$RZ-?7-2=d+rw{?iBZcycvk4^;nM4E!c|5&CZ{w&+^&=TqCa*FyjK z-mKobL&0qs%|go6fBLg5r!O5y8Qm$vd4TWlEa%FvK+WcAJS)cg(9&xCcNp#5hn{o<99RFX ztI6LB$hi?KzxwZF`r~O}qW(J>owNoz91Pa$NK^kEOl@*wBe_pSp45Nm0Wr zB+l=f99GhQn~})_;QL|7+BnuSkE4X+DBT^T&P7r$puD3f@uW`l-$j&P)_+Gp0rlU7 zSn|(LeeF!j?#|s+tXr%9{5Fj{W~=`$!3wShYk{`i7(raj*}+icM7Vrx@-bEaok5$r zkur>5KfVs&S0&y=4|@Zph~N1&>Gwujw}@W$#-#sFy84w+V*f9$*h($Cbl)Pvv7s-v?QlIF%OcN8B6V;G@9jAYgW|ZZe(R zy~+CydiIr2|8lVPX?%H2{2c#X19i&dzbj~^y~Ewg-@wtabLc;JbTO32f46ewj!L2b zo+_<2ybs>DumA4j{=KYVTt-~zKX;qIk?Z!u+o0DMXx+cy#jF0il9idCL%VD7<+znM z%#I=Lckn;--=omw6O_M+JfZ)-k@VlQpP!|0b22&mqnG{G%wEu5{pbDAd~vL#q+f0650#Ad zzxNwM>OcF{9H@3IWv>B8_1{`BSN|OX?cAGg4cM#yR;TgbGU()PXX?MDN&lUY^q#VPqiLh#zq8OW>c1Q4RUgWl z!S9j|^xr>|?_2mBssFy7^xv(}{O+Xx9!UD{P4pA>-v@a6OF7<=^xrq2^?Q+qXL*n6 zLEifc{r7#|kW~NO43B%WLzVhZ4Y7$@o@CFegZWKJo>J$spU^+I>c0=xq~CXu_6GJr z+D)Ihhc(g91N9U1$fG> zUABICq5pdGZor@Mu2KK}Cld90c&PrHmj8u!$Nq}`I}!i>!_&&A&ZZZ#`Q00yOX$&}Ai3Jb`x*?7wFrU6-c*dm7T^ zKA`6!nHTem{<{_Zy%C98&5G)DTG^ZD$pG-*9~nFynREPdI=bEddnvLxnO6AD_yx$~ z-yv1@-%C5_zZbXDf3E}PL1gB7%6|wBMgQG}H{E;DUAt2M-NbvFcfjx0)1y|yr$Kn# zT?K}Br~dmM@H!LksiCy}PI`&o9=izoosTTbx2JhJryY{Qk3*zyF%}`wOW32>ks}6@PD` z|NadAZcqIE6;k*sdkEpAAR z`hsiMTG3;TF0B2o;nW}Gpm4r9pbR)x)2>io@O@L)wza!!^9wxcZ@&`n7*4ymoUkRX zE54Q>_gs1E3jbY)7)qViD*v5p`xVi8L#)QRH;-0Nchz+l`uf|irNFm~`|{k=58M@> zuJGR-fc$D>CI35GuWQ>b?Ygc+XoC#?Yqe(s%oUc1G#AfCw?si>o(6Ta%6`^sA z`P}PgATx)(UnBpQ(2Ew){}1j0|Ic7lwi?%P!`p|q$m{3-Qzia?m6??Mf2fQ6|5^6S690b;_uh}qOZ~6i zt-i1<`~Nrp9jTXRE-`-z$`yAbhxdwkO#x%v7NUHw$Q?P#r6iy(9E5Z{W_kV755>JjKk*y1b4W%KnH^Pvi@H;=B_3fOQ5W zbl?@(Mw!l#%4M7Te>aGW?TA0icYVow;d2-3P0_YE*JH%o<}KReT*`Z02{CK5K5Mi# zXHVf%6c_|m$|VPXqwest^iIqmoqfhV%g|fO(&8wdmSWy|gV18;jLdneeoV$uVfbJTirKb}7!{B9?MFXzaDV*Zx_b_v;PLnDxMN4jVIBz0`_!de^ytb8PcP z90xC3G5RVzeR%7i-^cz2Qo=SXQTo_PEoI9)&Yh*Eb7n07)@l2-1xO{a2_A;*Y9R@n#4Y&k ztk)~sCLdhitv9%Xmr$;Q=`$xr)~@6S9&*IH;wI+uC_I4mFm%=%QmWUmb$c($a3)&r zztYcA>Yv?8kv<6%z1PJ~%CBezr#_d;_>QLQ7kE$A<9?v>)oUmV5W zd%kmNYdo(v*mfmF%SG&CrWdgLZ&{yQl^1f~YxPUCL|o;s`|L_LJsYKSH|~f@=oh`I zq@nlBp^d=O>c>yNDygCr>FpGKRG$Oesppiv(-r@~M~tXZvhr~HI9!RMnh2cH#t|fZ7>FeoxrTW2HXCqKbYIti) zb8TF{Q`(S@+N)yES#3UQQG32#Y5)8B&svoq{Ydq;)~_t|pMG&+ebQgscKY6^-%iuB z&hH?q6Fif4Lx}a!t2ekGh%)Z(ci}&)H@3c?deKVLVF?fAPU?jIbN(@uG$n2bXJ!2- ze#H)T;^KE0_0AP*cRr7A26jdN=`%SLSoNQlP`_v9Uc{mQJPZBj7yYz$3?^6j_xg^l zy2p0dlPmR~W%LG{@P+pqh3vp+&z5QHsW<3% zSm;0Z&GV~gTI+m|cof(AcI#QFKeqDb_Zof6!Y@v`qoMmV`i%u;GxT3rsWV{JD(+cr zn{12UcT<9u-Fkz2^-rKKEuZc>?Ru(y;?_TkYrg}h{?ng2^q>5#)PKIKZqKaLf4%`d zidF`-3jH^M8q7J8(&`O8u)hYbcUz`_#Z<5f z{Wpm_6Up5ZeAIu_67AGEBN9*Q!*CXDw5>BKL2quqS?U)d)qn1q?{_8rlEMh6ri@9u zUO*^Adh-i86exMDH*xaw)H{u|9*cT4xXl>NbS8tqd5O@>A@$kCIW>Oa2&(3gAjkViG$eENhv%ATgr z^1O7ne*HHa3w5FYW`LdJi_m{FkrjWV;Mrv4(XY96r@oBG z&E!@8O~gOJ-M{*ie=dJBxL!t@{-lNeTgJWq_yUcgu32E*75(RX1xmzpEOUOnQvJ7A z!g&0|M`4koUPY*P|TQd`^XH&PkXeg;OXrFskc&8`l z?!&tXX!W07?B1JA&eh1DUehbOus$&hYxqP~6bk*fj+U$c-0Ns>Xr`Zd4>&#&51U0C z3;pMJdSm=ID*2tcuc~<$L#@5Q-~d{o{#yZ-v+=>v%P#ca0o3rnum4tn#YEO72IGUi zj@BFkzVo1^y3Q|Z7W(fnsHJay4^|=6e}{8D9^CqK7UREFAF4?KbnLN?TYD=BjZen7RcB^jMC3h5lPX?6(#7Cdd9*#MjWiLjN6%hnRQwt`|LI<7{|#0GRZ^6RQuj z3H`Sh*ep%I!&vP(9?ftNSaxSMC-mQb)U$zF)|2M<1J;vUn9zUjzOjVT)PE;{>t4vi ziM00+ac8_yT~D5^ z^&v;DLjRotJ*KdLjq5s~TZ6a+f zK5~b!9yJSjI+3(d_!wV>1UDn0>c124LfeK{*-U!*QE=z%lK#60>2&;eBQ5yf*MHZc z|K0!wgYox#cS-+U2`x{ct`9(&Q_(h#|2_a87SM~1V?FC!^xp@$-iil!=)Vo*emmZ{ zUDJPWh649d!Zy~owt~eP{3Ex(zbnD#LL^&1#?XKI%fF4D=@&-NPx@~sbh-^()PL{i zcQpQnq5s}VnKSTu+=uTP+(=)!6L0RTz;6rvzAO6gjYUgWVC-nkF5!}qQHU4u+I{=2QD|K3lI(0}(r?4khgKFn93N8U_LA5P!$xR11Z_`8ps!szR| z5DB}Uk}hi1e|OQ2Cn)J3$bBEjd+O~T_#)m+kJZCE^q;MMb`Sk`S<-)cE)GO~h9dFH zki73D{r6S8Pwz+nJyg^9kBp)_=EmQU5&vMW!Kp(`ox3O8V~~ z!1=RiiBHi>@1Y+qg&rS+YCmK(_!#_HL;u|br5ljPpSSA2f5LzE=jgu=uuprT|E{J@ z>c1Okh5GLc7*YTh4CzSQypOB`Tk(BG{5C2M8SK&*p{=1(Q?$Cd~#gAA0 z_mNip=gwQdLjV05tiO-`djwhh4lV9Q3qHyl59+_$)A;ZI^k0ns{!jm9$nyWU^`Gkq z#h>GV__KTEsgHS#v&z_9^##{Zw6vMu*x;QwkGMEbi79V^N5EM|t>B7A@n<>3%B$x> zxz-$YyAEO9UdIZc=f#iHIzwP@X|7=y#M0Fb>nyJy2L|HinnJA*YrU3WzA}BZuErX7 ztp2*17wxo;;?HyIw-xON?Ovw4UKML=V($8tWq2p>wsh~>Dp%oxYO!W%3AI8&dt+B5 zv|(DdHM+*>N{*{FvHnodKP;Wr67;W4A1$Vq=c;I|dPooXC$y=S?3#(bZ0bFtZIv)L0Y&6mzH^Bf6gVu-PKW7=KQ&;5tOPuo|E!=Cs?Yu z+8%kK^<9ZlUi>n3&`K+@wqw`ZuqjYy& zkT$NUSVC?5cWHvRpm(3&!pc)0^>k?5yK{Hm;=v z%?kPVTNndLafhs0!48qqo0%R4MRkTaBVa5g4W}$^BYsy|`5(ib5&ZdO zBYn)Z^ZQK;*RYi)S0k1G;i+!h)_w^2cU{zPT)Ebwx4iQ27stj@o*wJIAs*|`gE^Nk z!>DaMWqa+4U9B(*eB57WGG+F|(iieS9xeng-TTCK3@PMJJbn+X86139)fGqO-?xhE z4D8IFwQ=|6d9<)XIUq)?OWv4Nh4Edj(&#U}TgXg`#q8T2zOSC&g&*0iGzjY-4zTw`Td8d0`A3%BWJz>Ak>b^K*DM$IA zL+z`$TFb8)9*oS^&?4nud-4Ib&~N8{A^)qe$c6kb#%`$muPn*`;tKg+o#emv`xpbE za>)PT@N){Y|7BoxJoi?DmGbWnE5}h&$p5}jrV-rb&2%gW+KgRksTF*S-}Vln%zd#3 zh5Vla#Bi(|%Ks{?gu^MRkpJcIb_2gv)W1J9^#B9k*Ka>;D9QiH#4E8Y9RQy00;ENE z0#+5*I?l$e^iqH4YZ_%6!+Dt6&k?$%q0K5-Ek5Yjza!7w#t7CT-;ic z|I@J49E6o_1yIVx=}G?A)G8hs2>IWDq#c^%|Bb-7N^oJK@qS7EPoVDk@WyYVxXZ{o zQWsOhEGTsb+^H@9hrqqQ;BzsMS3;Kq;n+&-Qz8FXAg>oD`QK2I|BI6RzX@B>3a~gA z8`&D{LdVp^-|tP21@m`+;bquzj&E1~&&EQuFZ*^Y|7TI^LM+9~|LIBochIK#!|AlP zCs@Bd$^TjKZ!wn9?%4EJVj+4x{d+MIQ|SM9B>BI#X7T3&b24=4iv(Vq|^>Y@N$W&ReiMJV+@!u}M9G z{C_gZ|J#!8S%O_|3HLur*`3M%qm(oqo}Em*5^Gqs{C^dj@F3oUey~;k{gUq@dY=0K zQKTbgJK+4a>;~~u+7t4BJzNj@f1nn5us%+s zwF{8rk7M6`7d`C{SRsEvTb_qH_pz?w`})uDj>|plNq;}@r9Vau>quS9Tk3c6uKkZX zl>e`{%Kz8-cBAtD4eM_-ivN z@OK{CdC)$fr(?|I!vd%MCg%2?!)sx&{eg#8F=sD@C8%@w@XL-FnBy;J+|DMQoz+i4 z>kpq_Z7r4-K7XCpA9g}(v_3su#YkIQ?Ky2_sakQw+IfsvSZ~hn< zcOHWO`gV)AV_U5vS~;A@)f>cB{`(bZ`L8`B=B}NUpk*oiiQ~&a`g_WMeR}JuKltzW zKD9jP(^~M~k#*-G_&=h=f4yh5QMj*ief*bRe&uFNg4A*oUjo%%wm$y5^LFsxFNx|S z>s(?CckAI_PjUwT^`DjhzQr&9$9FJmD$_;&`_{d?5a>gvU#8w|zD-|yR8@wLv*5q; z<*`se{%c>D);3!^*OL?fow@2o*ax^KC@B9O6Luc@FpJldZw_N|{jUdd75#q(b10ZyHV>52a{ zlYPK%c^CYj4*!>Q4$hcSzsq${eRYZdYZ;GCVVt%&Hud;{|~3t?mjs-TZ8=V z3pLzZuCs6uQhH8_|EuUTTkyizisT=~$a{Tfz@+DB+T)Ow7APS9j|cDWDXx$I?uVrx z?pe@&zY6}J1OG3nqkg@;PG_C}cvk84yqe66$bH=oWZYjr|F<)epUZguOniH8;A|5# ze0P`le>?N1=>O;7N75DkUsdA&qj*D|MgN!oo8kXwnOk%ouA}$g)yn_fz+A&z=XG`S z{}FasJBRt0{oj29wlFLD8D2q8@a@KjI|i6Nc_Ko_*?XU_eSe1{03@W z1^<7Ezs8eL{(5#EQ~#gC?C}5i-x>9aIY&8P&S}giihFV8{g|m#r<+>LR2(nw2``*a z^5W+hGfFe1D9!Pke)@wdzvW4Q)e(5ejYXv=qy z9KpJSQ>@9AF>tlc5w2^9+Ob^+b$nWsV41exQsNCV*At6WF}M9%;kCFqw`s5auFttP z)_(h4xpeKoQHkqwmE}kKT|e@jp83N_gKk98C`4{K`t( z_KyOhXuo625wyp*hl(0pSF>i@?>dohR#leY4T#Z zbidKyTxLqC{qCLKhjPm4?jY|ML@L`~>~?SIe%(0QKcDuG0p7P<%J2iZvn;jW-Reh> ze{z)sM*HK76T`47`-X_)nxX{TzZ8pFKgIx~N!bU@Us-<9e(lkdc`mz$`|?(3F&xUT zcKg@S-sL<~g8v&5ww3Kaywv^!;KF|7IuKeMT2X$qe=nZz^TF*1#wpe9Z=uAkrS`8U zeIu5{${sih&(FR*R}Mt_iuPYv)&8Tfm0d)gMf)$r!dy^C`QHd#&Vxp$(EhF1p)bI0 zT27DlpGJvi@>BlLuP8mkvU>*4#CvJk>nO|i-^dfM4F5^me>(Ml6fE2^`asS`~C5AV0LDn*K^Ku&U4N@bLQ-1r}c%d+bz%b(495?@&Y}-q-M)@ z-hTAA{?z_7%SIlf`9As$0-C9zrSf&wY zp)m_RrA0RBN=Ge7^Gx&?@ixk~vxUYx^w)o+OTSV{S0Vbn0&11c$YW;R+zM=M~zXhWa6g}0m z^M!sZfd1Auick8jOzOGx9t?V?)1PbqK2H0S&947t`wu{k2f%V)ZvWoA_vhN5MqIsc z{iOCE1W$H{7YCv){ZV@xdG2hXckgt=n2OrJ4DG)wuH&lxd;Y2Rr>9W{ar^heR<(Z= zBR+Z}qdVGlXYJP!&o7i?PR+*Xr5j2>??qSbKM*C^dHeT;$LSmXacI49@CA*8cR`Ny z{L-KKD?obsh5llN+P^a0{-v1PsbGKX%zvX`eGr$E+P~6i|54Zd~W{*J4+5PwY2|YwErxO6IJ`q z#h5eub0KcVBk(jvX8X^>i0{w0|B>AOdthYP4e8?C{`=zmr}p0)W?GN`Zu=jH_CF5a z{4YcesQu%p*|BaRTiLe569b1}mS(Bb{&P^Dh3F5HjRe|%-&Rs8bUNCfp7Jm-CuQLK z^?5i441Bx(KWqQn(f+rirfbk=sQu^Ty)11pPgjS0T3@>1H!*wRd;1bRF`(N27`*vm z6~2R~^Z&ut6NAe3UygJyI_>`${?4d*r|Cx^1^wOJN|fSqcw!~i=eYeZM_)V{>058V zbMW^^x1+ZAr`!K3od3^q```E{+W$tJaW~-n{~hyT)czk~UhZAD^J z2V$-B*n(ItCLrG_bn4NoPk+fWj-G?+Ww3iWwl8A41?yGVe;Mo5*nb7j(e^~=nCe3HApPBt2i291sZL!T z{aM&z0+{nU4*Srfyznv;r3)L0MUYXRw563~Cny=)J_h>lL+02??2mm~=c$$LB0o-h zJkr5FmJ>`XYaoKoWebZ#22DIPh!0Y`%h#04Ax7qK94m5SzD~zP;L0!*Z^4vtP_!* z+F~+f@FDw?XIOYK1IN_L!fhSr~4 zOm+;v-CMPSs&$#3Md)!5Rx{wmfZu@9ZZZ0!FJ7jA7-jp~O5 zl|$`JJ2#Zq`nR}=tti9eSl>j_N3b1^^(n0A<1{6exarUBw_aQ-3`%3$IXMB8$)lXO z2W5U3>*=WXI;`lW>_hmD{RZEVuY`Q6Cj;6=x5k35Y-%@ziI>3NKpqca`=qK1*J(ZW zscwE-8m@a6%gV{g%?$=^J%8gqlGxDh%{jz0Q<-$Lgr zn$YHo(WFUh%PX+^8dkKMk#y>Fh0oS)PpU6*=UC4g#@TuROKz^UGy4xf|17MiBlmUm zV?H;WV^3d33*n^8$*@TJk3vR$jmkwU^+9*Pr7f%+D>s;vnf^A|y&d*9VS6XGCt+KI z^lPzy3ic1d{;yaMg^fS3{)qisvArGJJFwjY+ZeW$*phEf!`c^V&&GC`lb&RQu}>U~ z@^?93qmz(R{?9m^bZJF;vPU{p2C~oPq4Y_t(AUy0M;hq6Jgt8O@@v3KWpV05<>C6k z7L|wdr}FIy9Sn`x{$y;YJ1b;=c0nJcID(A%)a9UpQy7;G3lm4QQ17(Wf1ZpaU7rPY zOgszu^Vq(Cm9EJHag6Ibk4^ewI}yhvSZ83Rp*dET;W$x*$sEr4xyP{EYUhHaj6JPrG_;#kQ31ozWt8%}=dea~@Pmc^czr}tYaUs}hfyu<|0 z#W7Z{FM4&tSxJ_4q4R|=LUfJG2?TQkxuIZgC>#!k^YU;Nj^yVT6htD0g$0F0ZQ8VH z+qS5vxLw=gcJ1-sF!3L)=(p^O^O<7DZz#v_SbN}@#;MeI9*2AZ*2&nXc-f5oKf9n# z#T`0z>DHt51c}eUzee80NboOgf50)t&~7NlPuTwj`!oiRVnux8xQLj+V`Gd*61}j} zHEr*}bz>iaC#b0B*jTZ$oTu)cuf zSFojX^i8a9}<#WcUUpbH#$Mq87p1u&curA7mthSy4@a}%C`t|j2q}0&f`_YFupgd21DHD zvE#dty@!?h!<|?$4kSPESnXnL$ybz)>P)^`jP?K2;#8Baih*3jfJi~du6}uMgz$Wn z;R0+g!b<%Yb>i|)#r{p$r`U|TyY0vI2g7uty3SL(o`7{Nj!(w+cx+KG_7U}c)GILr z+Y+q*-C`jbt~NQi?6hRy)T>3{xAz5Xe~Fduckw{QPcOHXN|BPe*HLP2) z|0=fRkDV_ju7a&D95dEI<$C0KEw--DVmL@{}S;&vBdk11Y6f4eI zzIJcHc0IUS;Cw9VQ%Ri9^f`v>2j6>l!?qXJ-LUpR9#mG?@@{$j)&$uhU}`~Waoux| zyjzOr@GYkNR6bBj?1Hrb#~oU>Y|}jsEB!=EhR7a+8`mem?vnT?_UQhKe6bcQ`Gx#* zKl0v;bvE|rU`uU}KEP!`o8Sk})L8r_Y|#%m*5N#)MUG^BoTk*&C$3Y8X6%x$P%rjd zFYG&hW8cLfuY-)*2l50RlTWebISo1zTpTOB*O^04fiZjOu8;%2tr+y2FDhUh+U1oNJU@f|EYfolm59$oh{{y zP#6khkjIlqJfgE4x_4qa?nOr7-_*o7v=&~{mWU;$!4q_5@Zx63+rfy`-4eT?O?u$p z0RHTe7?|kJt?B5)SMGowU(TZK@R|+WMWk1faf>?obi2T3kC}N5GGWxrEePf0hB~$F zoL4$#d~6~oaz9uBtwI0LGw^-9m22e`<^>~GFt;#l+eN{GykJhd;)0Ha`E4R?@`B;w zaNFX-HXXWj?$WtK+m6MNcEw#f4jMePq-@ym5#=K*MvWdjZjT9-jscY~ZYc{RrX8?@ z`9%f6a8XYC_HBzp`R(&Nb?neCuVaUfJ^S?S*MGo3x{Aq#oQ7~2F>`YAV4Tv2LIo&5 zVR45pyGD1{hD_+!kw{TdhYlS(cB0X5u9=rdWAnCci;LU0-=({gJ+z8wPL$%{P8N#R zG`E2WNcUcJ&lL=Zf}y-H#{K!>{73{>|H6WTHf;(Ei;CJ56}N5Mwp}||>(H)!hmQE) zsWbj}=|X0>I(b$gH>aQ=ifP#XLw90arJ$yvnO^*(ONX78YvzP-A_anx06y{pbpH{| z%P$Co1ChLf{2;n&eqnLPE;O+0v3s8Z0|yNrQc_wrEYlj72i3DeX3)$H2ZDjT+;AvA zKR*)84;IiJO+gs7=+wDuw_X%ds37n`Fc=I&sQ{x_El2puMt8$)Q6wLa3Q}Narv*c} zTgr#4GE-1bPVA2LCam9q;y%I{k99uQrBuR;fKineo9%|LMoH_0Z2 zJz6Li4tIQ{j%nBBj@a03mtcN4Clm<<(Wv=(!MwbJU?@L=Mpqh|H>$AN1+k0+Jb{Y1PsD(MP{Yve4x3RWA7_@30&Xmtzg zeC12@#@GSpC#>b-nnh)C7nF&|HM2lz97top6S1zxO5+}kg?Rq?V{9>w{2woLK2aP* zXX5b-jr*vsO*lRcD~%mJOM=cSO6O5(*~QORB*yVoaU#YJd*V7d4ZfP* zqL8siSI6!~4_priU?fV{OI~1=u7C8yJ)Q-fvem_->btvUCyQ?)kFZtae*${4`mc6( zQv99b(qRTJ3KgS_Y0H+?E~#D?ogM96lV=!1h74U+vtm)zlG^&J#dXVSR}QUjm_BLd z#HvO0GaHsKs;Zn)TD72eO;zueRTB=FH=?v`$Rhkw^2F-;`sIz$MGdvpjkQsuXI=fG zWlc4;(XlHVYwGG7hb$eBr`yxQy2B5Lu%WJ=<*NEsRfi+9x@gtmw5?iMx1_$Rc12xj zc|Vs_4~n|G3;Q1vMOkTC7#-)PL8eZUg-~_!sckHEgr)uakBNr;(p9f+E!|*|Fk0;~ z*tBffawjQDx3K@1Jfoquv8kaxT8-V~sEDhU*VROK;=+FLMnzTQfT;3uWz*t8nq+qE z%Kp(~@{H<*%NrW&>X!_P)`^B2I+U8HcIC?Gl7{6?E22l%H7<<~i&oB9sT>u}SX@^g zefZ%egQ9TVpy zjamF7b&|e5%+%TD<7ZuGyOG%zembFy_VU+>iZ;!rQ{id%>^d{keWNvS^V|Ykd^d1!~Q1HEiBrzu=8GR z@{bH9j6J%J88EEZ?j$CiNmy?{zIbfKFeVfhonlQa$hFTjVVZdj#2r!Ix}IKM(~~%* zrTWF+-|{nSBg&y=P3+b0c)zJPlZPdqkh$9RwCU})KF#b{%wZwCwmUn}yG z?`+*K+vxEl?_#?LaaBHdZeqJ5cjsS%&T%Jao6L#vo-5zz9J}Rq?KzJsrN8Xk@rSC< zYDfPM=h*e9Atl3yl;Rr_2GO#T((;n>5_&BJ zzRc&Gl)F!HIw??o(m%My?N%MbG1lS`1@=u^f}dfg&oXo0 zAeB&HBnfkJW}(aF%*J_OJplo!wWpjyIsL~2%mT1Wh6Cg*KoRZIF|_+DzHhgORbn?l zlYxOt>En8Qw`O=Qb~DRvUXDkXjo<>q%%>fDePT`Ml~4?t%3-t()){6YCAQc9 zc08WDqb&PDIjA4tM>Y;X(|<)8$txzN?bPsB_o&1Lk5 zgkgJyt2vtvlSo5cf!IgM{H*(k`( zct#^<)wfJGdr6q==Ac)x-7ZG{$p}q3M|FWDY;Scne;~U_1hJfBhB4VLNLf#iF^kQD6Xocc7A zv0lP<-+`QKg`aBP7hNakjBiFaUOyuUjnsJpBAD>U;@pgbNJ#bmon_zb4H&T#X9wUaBL`S2pvjF!eg zQP=TwNSdo%O<1cT%}38>&6%#|QdjdDR}<&Youi?dyq`6fx|-+F;TC+*%B|Pk2%G>L z`4cBX{mD;QJ>jZ9jKlmPyMa7S-{pkuWtNvvs< z#b6K>?2g0yUd13=4q*}#{*<@h5WXT}WMgBkLz!{o`<$eC;%K}L=Q z88V5<$AbKd3v^)UAxypyWZqzqlGRMM3(^sfhXqQ{WAdXQy)mi^l-cFUlO!^4Yxj)G0W0?#R#KNO;fiV{`DHG&iN;7s7lL|qm<5Ufddx6P#LC(jc zXMyn_Gnphv)2<+U>|nB&An&4Y1Y(`TsMg!=zD=!37{wUS@K%Ae|y0Q$J&p5ab{t z)2uwI=_!KThqE`Z*Dg%X5@ag|2Z6oInVcucuZSms=`)#Z5F|=bVV^^pTq#I3^_>}O znOrBxR9u+@`(DZ9WZW4IF~9>-z+28yAFr5crm`c*Sc+{+wktb=yhbr}X&%m?u$>fSOh1siUQCRU zUOR<*gB&`ZNlcIv$j)K&m?Q+LrWm@cLD>f z2@*lf4;=F|lY}6X;g`U%#cjAB2r>k{CUD#!CdOE=os~q6-;+s9ke4VLt%);92=ZB1 zki^l-jv&Pt90yLgK-n4RwNqh$oOrvkBgj$vfSmN4vLi^GV(8kBlpR5yrWktiZ_3Vi zubpCwZKreuM?Vl`8O6|3OPC}CIh$hWX?rnA3Nmsy$mumqj6J+|?jbv89IxyMQqm3N z%nizpAl)g3o^_Y9BM2UXHUejFQFdZpJEv0&J?9f;N07%lf}D%rYC}yEUcxc78{{f_ z@+W>*bQXF{;JgynPrCX69OmCX6y*H9R8A8d>r7sw7B;)l0q@0dmC*CdM=`nN2bD%B9MVAiXJuUUj0fvzIr`2C~z9 zxw5mjm#iKGay5-laKk>`OGeOnaLra_N02XZ@&vB^LfP5Jn`Tdnhu7txFQT{4@Dfb6 z8G-9}V`A*g$c?j^BxZWkJU#?u<1%GumX}<+E67c!FfnF(NtniZ zH#aj$3UUy|&|4m4lGx9iX5$QyTVH1qo8u*46S?ghWoLgc*_$He?V{NTnaWoEnbfdB( z$cio?k3FI6EcB+CO5RDnr|c~9l93ccAOBI=sqvC&!$6)WLR3UN5ajAokS7N)Nl>T2 z65#mu7RAt~CNYUE_7IMtRgiP^4DctWbe0rC|Jg>?HP<6`V(8XGn8XE{KxzKAnn_X+vmE5r^O!^r^X69959GC5nIr@m zOEL8IXPBe}xr1Wp8!0BSW!~J*r5O6=uS}W+*_+OTx7s5mqU+(_G_Onr**1hpT#&yF z0C{^VlcXS1D2BeXkV&-Oo7*-0LEb%fPB1|NlK8hA&`G2n8X^qxiuAld~zw1WPIWRNc`j7GzDw9%VeCB@J$cVUtcWT^r2RXLNCAU9Fp`FbXkSd%xmbreIt zIh0AWApfEm`t4dK#wu@`SUZsIS2BqUayiA&?=~|@3i8N)Am6{rBzmMbx4PjV|N4qa zLXdaJ&JVeWmti|4NStEmzoSfItG&7HOEL7v(M*~JsU8OM(;OzoQQkBUl!E+R&m=C$ zw;e%#IgLruOE`vJ3pq#6T>iwp{BaaRf7{IZ(W4z3XX7ycouMGVzse*b$R89#cYMVp zB}iZ<$RD}8Q2k@acyfz;NHNqfdoXGi=oW+y{K@cGM#iz;ROi!~V3~6n#RWPb3}l-P zjFJLfIv6O&JeyJUIB$mavw#BTMn(yN9>;8aAlH17QA(iBC6eMYh4y%}z&-WW1} zVbmw%1oF(GjN$^_Fa{{!+>23Cpd%?ZM$B49(S$d{PbdHt zmoV0Sf37$pR{h$8H6=H84_0!^Y2+udBuD0Zqh!v&B9qUH&VngvQ2 zKt0UM85yT}Q$0>mc6alBMsa~QT0lL`R~aP*%A*qYGQVaNJ>8q(Tnd1_%}|u8oDk@q z-GTa;JsG70dV@l3UvoU8*csjoPoP-a&z#SwS)lL9R)4dRk#VLs)oR41zyR}HMsb1Y zyVJlx^JYd#fsUehJIH*RQS>ZthJT}gJJ?JyN(dCB@HNEz52KV9amel1!wI=T4!QV2 zmGcXcpwt`$fGBykW5&Q?WIM&&GII)}xIi5S0Sz-3GD-;4jiT;w^EgJ$0!8Uu9bs-@ zloaR*DtEbgH=~q5H`7Tn(tMebagMiyhlhbG%+DD`1=>Vmca)ifc1FDfT1#PfwAr0e zT%e1Pdti(?no&Zap%iwL~p zFf!JA>veqr&`k3PMp1!2sRWv3p2a98&?^z3+2)Om;sV`9L2Wypa;Om!(Z`Lr1 z2~^(>Xo0zgQCy%c=$nB9%}W_21p0bEpo7eN88r)Z35DH*&8>`*0_C*_I>h{vQA(h7 z6n3l3+&)xg<9u(u*4RLCvj?N7KO|Ts_om)0fW#f!?NaA7&0&WlNxoDeN|wpDJ4doj_rCrD;I} z-Cdv`DC{B(cYbormGWTQDEKqbB(2-`nvL#S=3cIV#)0M3a zUR!5T*geX;PT3OZQwqCBn~y150=-F1d5rmvvL(>26n2j_|E+9Y;;9ox<)Zrj2Gp^cUz83cIJ8yD>@$ z^i*4*)67wfqL+JZ-7^{JbaM`)xIkx6*geBsu51ak$pAXjJVV(M=sOC#XPMV4TUU5( zZKJSzwwYA61gfACo@2hNYzcHSh23+_AC)bEKBlm{&TNbBh_U~bURwe3{CaZ`qqsnK z4hK5VoWiJCAeuN2oNq2@MCJMV3nRhE&0-0q% z7n?6DTLO*j1hm1VX;jp!*<*{tZVtjF2i!1!BDT(+f&`bDT>ucA`q|~? z2u3ReDhCf-Va{ZG>>AmU7+D~^50}$z^LdNZ@qqx0Nrff!Kg%_8>z~- zm@hDzDbP^#^T4g4c>^NoQA%_>GE0u6^O@Q`^lqnQF7OT~EDypYiffexl?{3GTjM(YGB>kIU#`68oD z0!^d=<74J0jJ682%U(c9)5J&$^%CeDIvpN2cVSd?y|-RhQty4j9LcCepnp>_o-}7O znkmpU>Htrfhcj9s(9|NJr_IwCtrKYJc%Wy@YZ+}4XzMOO&zg@i+A7cukOiJI-)6L3 zpei~mpErMCRCI&4UYAp3d%`irOPoTHV z8H}R0cu}k?&^EJbD=w0(cM$G~Rp%-}1 ze1lQ!c5kY=2>XG*o7)+s1d2p~-Z%4cdBqL#9o|$O3V=Q^`!I@b@}klrpp-d*QBt4> z1^|6%9>geqr#IEhc|aeTM=~<*@}hsk$W7I6r=TV@K&D$8o?)Ih{WCH!ue2!5{ zpu14lz$fNE7$xrUriv5;eQNGt6usAr#!}z-%VbnUUV>p-7n2U88r*^6t(hK=E;m=o4u)ips@S3*~};<(Cu`ld}BVuDDi+d z)p|Ntzct@v6n)T(4n+(MY&XASloTkR`uulhWCRsH{*X7-Itshrn|&D>4|~xfs`9_g zN=D5B9kd_N59Yy)Vvl%Jjo1t5-{xvYDS_Uk)8R++d`5{!y{TTIu=|sFJEQ1hUQ~{Q zz|ZFMjFJKs><{#d`7xt-(wnN9dhf61AB>F0y{P*Pp#PX%QFGiD2=w_bK);zI7{#9O zrh2Oc=y!7_qm)4FDeUer4`Y;g(wpiUYUMx7Qy4{`@}eCbfDG$uMoEFTQ`j}FhZ)76 z_NMxS!mee##mIQZgE;Jd4><>1_2&h6W%gr*NRVrVMsjW41n)sFLf5}Q(CW!3CD0ET zQ3XQQct+7@9W$J20tK3|HJ?#jpiQ%Y@~lQ>OQ3}_f%2_$l`Vn7)E*Iwrg$-cf6i;` zt}sx6^|Z1j(9wN>3ayl~CD6Zm0kyIIqihM(i%zW~t0M-Yu=Tvx)<=_p+FGTI;sWiM z2vlrMXVfgv!j3@gtR;+60$oE5+}=7-*?PfiYZkg?po4XVvLz6;V4$P5S=kck-VjhH z>osLdpbG;)ovm+_trxwv9wSF}vBIOM%5j0}$Qxa)UW}Rrx@j6vH){_@DS=Mw0@ zfKhad*VZl6ad)+7Iyr2|1^OfpXg6yeqh^6tO$X|3-NGm(&`Vu_qSiBvqAz)Eb)#s~ z!}^d>T%dvZK)YMNF=`g*PU^iqtxlta1$vZH^|ek?wgj3-SDJp-mCDvDURy5`>Tf-uYzcJLc%T8+>&liuTj?@6(E3){ z66jM(HOR`tO(pvLR0>fztHJ0#ELO$7HGnrKtrtq8KnejixF3##9F0n z{mpA@&Tc@Z)_P@2psv(y%B)+JErAyI1{!8Pt858$JE7s$N6OZ#UR#|80FAJISGEM& zmIG97bw=+&^cQG6bq= z?k3m|hmo=ppfT2^jEvWvycp#T0UB%F%cxnPMO5x_)>cNbH@vByp|CsN`jSyfpw%;h z_ONotQEd}%dQ)wo298-h7)9Umq78ckO|Zr?N(!`|qDiGSmr;D1H&q_B$3&}vk@2<{ zjiEp@$vT@+vp~0#t;rUBg^%y(-tngDFbQZ+>q$l_fsUfEJH>jRQQ}>1ss||SPPKkv z6n)Q&mQvWAX0^u&fuWy3VO%T%ds#yn#sBV2wS~g&-qv1>jQ73h)&S6StCmr-KyQ+x z_OTL-Vjp-@CCD2ytjids1WHoa-PgL0Q6l9{byXLjnbzMJML+bSC+Pf{WqrjcDbVlK zr)OJ13{en~Kk}x!Z933?*6xgqe|XWyWNVH!j#0BfW$0yr{jGV7Vjp``RZ`eJz*@;D zCD3z&faY4~FiQN>o2tvMK=Z7d7)3wvqIDEN=UY!PN(wY43berbfKmKYZ>l#a)q&Qp zjEv8`X!&fQgRBma;p7+SAA}CJN*KjH_oliZehnOA?ae49&}Sx4m9>~r;tOx8KPXk) zI)PF2OD~#7VYk}4oKaGswtE6CwC-mV|H_+cKA}Yx#UAgkZ>nbqEw$z|if;F!qjG@itVTvjfwmJm z)H;_@{5x-|1E`B0X5Gxl_}+`Yps>5ldYVzQ7jf84LCyg;hd)C`_12G^AoedO zuNQC_nOXw0+-eKo!$$%|DeSJW1~D>z@TOW$9rp-p3Zu9{?@`!ouof~(3Utm)pq18f zjH3VcW>_%;sL|TMC?U{uVW1}KZbm7AHueEpWxdQO_MjP_`EIqC%KCq{9BE~c=1 zqE(FQA^HpS)-<4#tig<;|M6z{Wf{;~Ybv9JKyUW|I@wypC?!yP3WcXw$1{rk=FRY_ z=|HDimoRD;=sy&8PqXe}Wc=<;MKjWY)2&w+#RZyAw$8A=V3ZW-1M0nJT7k(_<>(G? zh9wks&$6P75&}Kj7wBwj45O4lv!g)gSO+kQ{o&2%m_xInLr2RhGsf>BZ+!vZ?r`a7ej>CLbc!hYZa>t{v@fmYxY30!Ek zLmb7}U!eXJTQ9PPFp62;438jmu{DiRvp^Fl>~64X7#X%V)mjR>mso2U#Rb}{2hgR~ zrHqmSUDO-sGV5MO(Hw7v?-RP*+R7*)(3Al{S6E*%N(mGS09|S2qU$622fP{9Q`o)A z>cOa4AZrXzvo)5Hk?TptVRtU%9B|d&Jy=G>q_)4tI-C>4-2@YG7&(N(?zPrwjG6_i zpu$~eUCSsX(8<(sueTm$6b(8h;0(W~uzQ2`Hlw&e*HPHL(fUEz5@-g6-Hle8soeGg zJx!tTCTjqrC|xM2ce1VdyI}8Ti~guHY{vzvp!T@MiZf~!=z_jLw_3+2TLOjX#!ltS!oxK%WxYWPPe^33L&K-8(G{u?;7Gp4Zmgu0VHL zyE2Lk^ectkyR8aF%>unc?RAf}AET5&IaK9)t$JlE-)pOT4Cp@VbY)ARZy*cYZ(YZz zSs-f|&}Qo~Mk#^9y8}I7y~8LP@!EQ(r~=za3xgE>m_ANAiD_YN$WFZOQ0(#wmxOq=--HU0=3%@=xJ*=M$tB2Tl=;Jdd3>XC@xTE z3cJr*a~L%XG?c>bbJlWYOQ6#z>^^Uup==d-ZLOg5>jmq2WlNyb5zPWGT1jO~p!pPb zw^%fULA?aJoWkx)){n|oTd%E!J%C=e+M*wX?YKZRu@`v78pNnspdaZp-)c=^loF_F z0MOs8g^Z%bURzN*Q(m=>Q?>*;B@gH|YlE^SP*)1OuUmI3TLN{W0Q;u(va;3Av1Oo2 zkwyxzZ&{x+iV3t24H~vtIs0&x1-fhy(AyUMVLm1X1PW2NdB+;fs9B%~DZsvK?awGF zPz?px_pB9+QUZOC)(HIFI+Kyn-dp(7r~|xj-M}a+(7xpP4=j2hJZ#4VdY8tvDeFB( zae=zS4S^4>pBNM5jrVja&YDo|Sr%b!}8Fp3HE9d(<}ta}*61?on@;dAR1MhStQodWcQ^#!A5 zfdYsMfiJDVzEtI;KyxWneq}`&r34yB0rqQa3?rkXw_a~js&A|V7)1s8o;?4pbp)fB zK>f)Z+pV)0#RWQ&0_=Czjf@fkoth8yz4Zj6W`XEImcYNPzcWe-bO;65AFQ7lr39)( zO#=V6+MyHUcBqrLUI_}YKUzZ=MFr|w1oV?NjZsXXd+1F0*{Wd_7ib^_*k7zQj1mGZ zp#b}QqPQBt5O6kva|=vgBKJ%R400QxN(r<+2Pj}a$;jy9t=CP2a_#pSMFqN#0&LL!g;7kPG77LEyFHo>mjEx~aqUpZ zd0eX=6~iA!%%Br8&z{T)5^jPnIE?H~x5D{$oKaGs0ty)s`xr(>SEt;Z>IS;f6xbIr ziU~BDPOU=wPDTlVj0jL0dyBFq&}eGlBKuQitDD!>u|t5`+7@~u0;oXe4g@N;cV(0i z=vz7=+u0S2k^=2O2Me^f_hV%2;*f#~WN z=xjfxZ0+i`MSmI@=wiR4Yzg!p#f7f+zm+Y4KA~XU%`Tcl-bf1cFFF%;u?I3TcJtcm zM6JB5y(goXK#vat+Rd(Jlo05#5}@w(vC5V}ztO!#)V^5R>h86*y%SIm`z~cmplWi| z?)FQ{mO%fe=-<=+OxY6XQEJLww!J@9*@${=9ZQ#!-u7;cVgfx!CG2C5Vw4c*=3Jn@ z_8dk@fexiBO+S0NvemqzQs{p~Z9ErIT*5I?}aUfB|8Ahp*(JE?35bjfI-LH4`K z*6v0?mhBV2IuJ0P;pcpsf`BhuVV}B?VeUCsBz#g^|(IYb!VosMKD_ zC??Qq3f5)zamtoJ4^U?tW^Yio1p1AxyTk3fm91W0TRZv#jj&%lkB$`RS1NBi?569 z?-@_vha+SpcloVgY5S> zficjru!#=I!cT63^dC6Rr#i&#f(6j9qi%u^DFIpN2RZk^bb=6BsJ6#*g1DQY7>AM3 zIY5i-`HT`SqP!w8N>yVwGD^CLQgOM?#SWWE{{_%dqmf{#eLW{gxe1PENOVDpJ z64cpma)OdUPR(z|VdQM`;$il8jN&e$ydnotxt7_H1F8C(Ttun3Tzw(ua-|=Uf11wN z74|qzka82Wr9&#$JS{<#Le~*?JtqhacFI+W!^qooom^?3&M4|4$}4hWPoPHoI!04n zM5(x3k70+)m41eFJ6%{;+i!4!xSQZ6I;3)K*AjFf3rE?x2SLMb9^#bi9q2`lqHF3g zb`M6zPzO<7k^3msvG!O-u@Y~pf~i2q+jCWhF5*;Ux&W=Q8yKZZJ*l`hXG6}lNk5wP zPB$bt$-Y*ZDRUAWNrzOMN3{f#Oe9!qzs?EPxd}GX;X_F9t(!naI6Q^$D_J5VOE^K?O)!QI$-;?R zf;(&^IMd$12~uu?Wpqdu?v@GA81ILX;B5POPGF31igX1Xl7)}81YfsDf^+O&IYE(| z;AJ`_3mpz|DxLn)uAUy+r5Cw)y?Qc1OG19T{ zBps54yeg;C=>!|74wuq`3oMq6D(skmH6 zNHe&D+Cil!UVxC0VgZExlTC2oSVa2UCO>Uf>~8l#wtIP%^@ zwYlE@hEc*r9Ir2-+T3V|<5baR7jY^(2WX?+i&4r&oN70^i@e$1gOM@HDL1F;O(nd= zUce~kqI8sRf}BsP^j+kudm_Q@_L-a@?k1?B!=!;Xcw$E;2z5q+JM4!^!`|d3Sck(% zXR6Je_FIfnE~305z3ArWF8g~%C8M1pbE+38*4<+lR8xj=7jddp6M^ov`!U+&B1*;g z#N#06!gVns^gCsN2kre>HRY-f#$n_ED%L}GJ)`KD2?j0v1No6Dbl3QZeLAC`qOSv>#*C>>^He23-Umx8GruauKEC5`POhm$<-)oK7Wv+72wF zdK+UWsA7EpjmY%zK+o7wMo|~h59UYeDb;iK7)B*7;#4J+>UsMBMl)T+sa8<8c+ozB zQQSqG>X|)&w%BJeO1OwpaR;~&axQUt0DJ~Y8hF)ygcF?OCRmTd$aREXx3@8Bb`gz1 zBaae#)BYEuq>E_q7}-W>n_akw91$IdBWfQS^+moX^p4%1QQSo|T#H01f!?zxFpdf%>M)a)W2h%}W0rR<{_ZFUil1=i5**+=$;j8ZP*%ki->pnuw%7?q57N=VnX zh&>$W6Z=I*aTn1=DRLX7`qch}QPM>ei6hSv`phMRYn8vz|ly}1M#(;G;T6}^GPR&OA&4n(Q!ZD&B+YLCj~oP?=z!^)%GwX}=G z^!k!OC^xiT9nxz`Z1tLw+|U=01qoQwamN`b`4zjNso33?`yIdaVg>Tg{T?9?&bc4* z+@H3RO86|=|C#oS!gK?f`wQ)N4qrm@Uui!YUPx*GL;L;0`_TSxv|kcFlJ&h@_wg-A?6K8 zvpJ9YUG7jWTQYAWky7(-u=A9We>tIxLMK4jIrnm^WSH*wbFZLXBV0+!S5kFD;R4#f zhH6`cY99|-ZipH%LJdmAE_fC@B&DWg>4&bg9i*S)Ah?!$zI>Qs_0HSESklKo7S{lTw|EU z)qJ$Qsb~V3==l}w+Uq}SDw;*Qy{LHh`k$NH?qirksbu#0R8!kS4YNcYY-?(Jm|>Qx zgZG+>UVyvJVe0VXrlO}Plc~qCiNva+uZdo}fe+WMD*BxcKfId{ldFoCka7?6Wj@|? zWN|SaFET$@e0A~ebbN!E6QELTUsYU2$Df<@jtv|iS$sBSH^dsv$IV9-UrEPJ*8Y5) zINFGOjPg_ExfO6@OszuI=i^fN|62$mQ7q%vB0T@HIkI45}&%gG#{&e&ZslH48&Z!3c&S;Z)=R z7KW9A5$r{XN=Uw7VKINUHG+E(qJDR%i$X>by^bh&=o(1EcFYOV!3D171+HemD5BR9 z1()5#nk!t*wWLYqf7I1Pp7c7R;ELB+^E6lUb{rPb>xhC4Uo+Vt2)&Ld*ci;Ea%>cY zUPlyM)q}}qFJZgokaGpQ7)A6tqTo?`v*uP;vkwl7lHEX#sb#WV5PBU^@VGThiel>e z6{Iwr`vutH+);me9Z~Rvn^<#ztGO13Mf5tN;7Lz1DG`KTM-)8y?@Y=CNumD*PyLC> zSTA9_k)UI@z$l_Wlnb8G1Cp>k)z$os?9%Iqf@h6kGEWeC9Z~R{{h2KF63+clH}_qQ zB6=NB@Pak0nQ%21;IN2ZM-;s15+==p(CdhT8}4S36r{2b$Q3U!NeR-2$W@;*F(x>E zW;?g^1-aS`QT?J`!hN+PS{hknsjGND_iew1abFe6w&L5 zf=_nNqY5Wn^>3h6M6V+XK3&G7SrB?1QSjO6Op;#0CaNK46MGm%^g5#83#(YunB-J& z77mMg(P_SA9g~@ocEq-?8f%&zfz`-i7V*?ZR$_ zZO!5!{c^C?i(WAW5w2*?E}A{3qhS}0&L5LM4WrFKAA>d+xa`rzl~VFp=Zh-4m>|L7 z7)&Z{t24~z!%i`sVWv5)9Vz7XKn_Fk%}_oxoqS0%;v5F1wWGs=7P?25v6y=+^a@DB z@T-BhtZp4pot&2H1lpjIr~z%LDnV7FP&?Bu%+IHiQz^p*>B3b&8*kU(vZ8QwnD3fF zvE6zVxb-S*@lD?@!Z&U3t-HrJMJ+X=`n1KNhZZ~3@khHBW#y0dUIF{#pYVxg+(n)- z|5I3iPt&9W{2$u1vSDal{i0<}HMK)mSCm(k4yb-UR!l|Z8c$xDd2GHlwgc@3_EO|_)qIDtAkSO*LsBO5K(tsZ(&{I%IqFlR6ny} z`J$>Nwe?lit5%OFEmQ7E`$YK%j!^z_-3Aws%5q4dfik+gz7B+kybeS4$zkqryh~`^ zKSMvjMON-Qa@V@t&|TKxcA+Nr+LgJVgq{z*h}He~qE*u2c4q5xpU>RdU95p-=w)j_ z2iAWf)XVDG!48KwXFL2c83?^ipB5fzpo16qbBhvjqlI2<5vhHvyd(2*dXjP3l8ju8URJeW1Q)Zk#K5JZs=n#)iS^U! zC)Q7CSl+Z^C2CSuHM>mK4QYmzQPq$pqt3&Jw<;fHEUcfoe5Kca$i8%h@>6y;yp?n# zT4Cj_FzFxEskE#_Z?6`)Y_Ar%Y_Ar%Y_Ar%v|C!WplrC0-4?mD+ai~CTjbJii(Km` zj@@kKk^Kbulva>?v}{U8abJ*Kgw&N>E50Mwitos^;ydzecD3R=`dPZ#FsehA?!+uh zcVd>MJ29&;mMv>2!%Bk_ga(QeZg{}J!#{GAIZ2x^nky}@Y80mvx(uHf(u0teRd7pW zlS_|4f0*jnQcf+z{Z2ZzMO`*%i(E77WG@@EMPD{3GbnZHK!hYod8xUQ=s%gAqt?i?l8y`$v1dz4%+rwYCq6{ZuxCs?P&TJgD4XJkUP zbuQQ$7k?$zGErjP1)PcQ0T$~HV6k3*7Hid4<(6X9(r29JN=Nv|Xde8iONMU@PxJDf zq?aX!)nOz2Tf&h`FSh7QH@3(%Kl%oV7JXSBw5g-7`OI%{f^3vnE2R=^g;YaKEh;Oq zmWdK)$wXEZB~jXXeN<60IxqAqvIIkCIFu1R$uoX21sRQ`evy$s)YZ^f)-^4bbxn(9 zT_INSP0K`ywM>*aOD57`>AbZwOl6|^QHf=@pmJyNq9fPzeFxXb$B}DQa^zZ_9Jy90 zN3PY%k!#g*8EG>(nh#V-WJAy?kZpM80+|A3 zSA$JBGpo}w?$}|a+<)Mr#G2ETShjdN6ItK1SnG`{6U_}utXHa(d!)>qDy!sLHY$!w zb(BSkwX!I2mQ1v=l&On~-d(dbl_MWz99`S6d?n_jt7=!&;g%3HD(P{9XHKOwD=EwD z?9Rv%MOi@;Cp0zV++p(FC0&9>dHaFK3Qw(w{L=oB{XQ+$`hjwr)(=Mc-ybNkmWdK) z$wX^FrL8rf5^D{p#IgZV9pBMai+s4zRKK!rNqucibkWl4hD;whskNdxa;%%hVg54>s7lOw z?1{RO^`9YeZ*ntApsop837iR>>>kJnZYZ?MN&26}KHW4emfbWhmfbWhmZhYglx@IV z=C*Fu;9Q|~2*3L*GR=24TFWW1UVhe=<)?yH_(y(6F0*OT&z6tw2$jEnQYg7>l$QLZ z4}q~?EQ4@6e}3OQwd8%1V6Boff&Q zV2fPVuthGb*do^|!!x6Lmr!C^N-DkjnpbNDM=nd*qAyF?BA2CXk!vmC(oJcx^io=! zag(XlA!D$NI;6)j-ad)^oGCHA7dQ!IrIElL0?VfW0Lrp`3zzL{xNP6UDY;g2Cx5LU z_}{iuN&RmGlvry9C6>(qzqz^Ve&F1FZhg|<3ugE`h9eH|yo-vV4gGo%>s3)v^*ocft9Zw_qGy{+Lw5s^sRFc1aZYs%v{xMOBb$76~ z?o}uBWn4;BCfW((Oyy=fS2Hf3bmFVI-wc4lt1nM8GNQUVbI4g8tvgeFZJ^amiDfgR zL~2;78}_@cqzd>9=h9;7Rt@bTvz5XE+0BzwY-;5uE~jRg?uxi)B&LV$G>46V0niEK8owMEVtCH7Sewv@-1Uxdw6h zGe!ZFo9{OU&Y(IY963X2KdDw#*41jtQmvvamGwl!u~eSgu2eRIE0wL_N@dAhDK6sT zQDe_o(Z_eHf%Gnv^$8v)L6-ZPmU~*Q(#}nxR&7VFRoszlRd?jF@@Q_~A$*Hm=HDWh z`M1ck<*zk-dT5`~c^tX!2R`$4k2|-q+Olxy-&rKU@AKhN(oHD7`rcvZ z{w*hI^m_)wiLK5Zhxl?q-SlPl8a3VAZ{t09HVb$edT z6*qU$QLw3!xb{YYtNDT(wbofaHGe9j^zm-?uv8i2_PrNvr> zcup%L^R%|CP+F{&+x z%FLmg9BO(S`Sd#TKSYX`xjKLL}7fVLUe>tv%G2Hvf3d zcW^4X*TK{x>RV7a*!O%^R`rwFnLF1yp(B@0rFL}3310IgSFu&kN6Gbklw7t>OFpuB zTI57&yx#RG*vBbs6C=;%G9I9m@S17%Av!f!;$S!qR8GpeJqCXh`=P3afO zs0S+-$yft@zp)c#qk5w5Y9}Ax5;;$g`c&I_fHWKNbqJ>^_p3RRky%MaRw7%Rs;NSa zeqt%Peqt%Peqt%P)_m%wU5Z=G%Em(@DRnJODsdKVoK5(frzn54HfOJTF&dO^4Qbj$ zdnSqs=6r{t?%dK^elyBh=PA@P#~D2bdAG#S*2hwQDSald*^T<-V_NLfcBJjobR;e} zhAv%xcrAVuYN+!wPD9mi5>+)WU%qVRQ2rydYW$6v^Ls}kGNo<$JhGo2V){I?pJqNk zc#vkTJ=3D~6z8;UEsZ<}D5$DaJYZ5?~E9B?6bJ-yX< zc&DGBS-wc|eMpDeN9pUW@Am^Sq_5<9ag;n;KKhxi^raJ8@<(6yJsHy8^Eny(W;Urg z)Ssd23H)v|sRVq%krhNXEY&knVP9(oC6<{WZzYya@)S{PdZjO&lrD>=tzvC9*Wtub zKL(UB9H9LCXPlH+RwAvfRl@IixU{x*LMm;&W?T|kGi0LLM0TRISj$^!W3F$-imKZB zY7BR4L|96v^j;z|zs-eGwm-CUhPF9)7jtpSJ za59R2GF607l!$++f9>`FC9bG}+lSgQ3W zpOT>-J|%OdvShAQmdurEWl)1J-9L`pebOy+NQC^<^u2UpS}c8-7HdUSnP_EIVp&*Z z;*8%lo4!A5)uOLib@Vl}j$GPBqh_5uc7bd}q;R6DENP2ex~D}hOWGorC2f&w9nG<; z)xeQ!Y7_G`mtkqbFwF)b-R$u2k zr%^`L@?|wu%NH+RS=(q-t!kt@gY@CFeXCYhud2ljLyb{|gCiU28r2a!a*D?*T7)Ya z8;q*O%c_^GWZ^>m*6PCQm9<6{eu(F=+J=?vs=Auh>en#nXPC%$9sx>HwW7KPE#UKW z(fEPseYuF!)KASARm+wyI?SkA)YMS5X!)|H!|OA$Q+{sAeuPnl`NRyRkr~J8Ve6Je zDAGz)ge$b?wCR&sJ$(!A{%}V|Cgn&(&&0Y3RsA`ShT7_y3|}fAHPtt*tgR_C7S~rF z4wu2xtV%wWUK*BmE;UI*bz?1l#Yj1>RBg)CX1Lm*+V!=o(N5H)xGQn?Xp7&`sH;cw z;8)01rucQFrWH=3aYL4|@r-9dT1v-7cjmpEHlx2$X_@?*aKJn~&cO+|7pb}~u3J`H zznrDihA7IPSZw?Rc!d?yG;RFI`5a%lZ8ZAIbBqnX@_@0~SDtHZvtvf)VjDqYL5`n1 zWUTg;hmDQC@;oEyE6+DJ1^n`l7+Zbi1x6y*PruMu=PPex{4mH*A8!vC>?dz)4BBUc zk-6ALv9Z)w-p(jGq&ia_KWpFK=R1RA3jswW`c03w#%0Hfw&nc|0_lN5t z_p8^ftY2iroPO8~$Fw|y)x>MNRycCBG%qQ9lKeDBj(3gl@|z>ykRk7kije-s4EbVFNZqv?HTg5j=X3{jP+doD;@a&N1m&)F&=c}B^mNJ9eH_%{Ch_} zHbY*BcS}&craE%8G%x)e`MeByr6XUOAwS5GCmgxkgI7E9<_!4-jy#zm-{i?3euyJCN@6S->&Vx* z`8#q%Kwg?1`AkQS7s&APxFe4{@`D`t2aY`H$nlOKUVeAv+a0;vZ@cBFdPPfPtVib| zEn^+|Oh@jP|6oVH)R9M&x^cWCPdM_ZBR|uTH)qH%apcJi`9?=>l*Kp)^=TOQI`UYC z{7FZi$dJG4=I_Yee*T#wevkhc#g|Gb(ZAK=KhWyoWW{QV61Tu1(KhP>X9 ze~}?S*^zJ0kYDD=f6S2I>BxV}kU!_htzpWOt{*;ddFInf%}H-u4qWPpoC!C?BH6>jzMSzH)4F%(A_i&-EDV6fN`l9WprGEi6M+e zeMyXxL?b$GS=5Sg9Vdi1YKT!&$wZCg#yAi)V{~ra^FNQi=iH0)&HFy-e!n{R)P46= z{re&PRUH8zDEv5hEc{gXk;2>I!-SVNS1b2BLilRdQOJ{CSt_)K`a@K$(-@C)I+!mo#~5Pkd_4SC;itlXD10G&o$w5PzwmFte=htk_@ly~gg+(x5AgNE--kaZ zd{6U(zFdbFg_k#5E4>hY68tscXTskS-U*LJ(fK>XreYLb4o`&N2+xGy4bO!?$^A#W z{a@z(!Z&k&;k%h1Oy%p%g&ziw#<=~*!4u&#;hFGO?l1g8?myP;{|)Xhyu1TjInPY^ zFSx((jog2n+y5QzFMJ1c*D>2)_#yCI_(*s(-tB)fJQ3c^{e>^%{=&b;{f~9~-^Trg zKg9ioKga!rzsdcNbNlx<9}LQMNQ55*&x8+$=fbDMqvPHFDfbutW$rKhTJA6WHtv6d z+y7ziFZ>1WFZ>1f zG47wZ{a@n#!Z&k&;k%o^2-tjp-y6~6FnHET{n^LClL@ZRghvxyZ{hyJS8)GHZvA!K zf3oXqx&IW`AL0JOpXdHl-TF7V|1{V8?}_7Ky6XqQbKwo}>}0ooDm?ju>*sR+8Lltk z{=%=~{-?P0--RbLUH=I@n&tWicrN^Pc-G|Bf6V<)b$!1&tj}q#4}<5zC&IJYZv9+% zGRO4`;L+)>UjfgB-@^URaO>~q{%5+rp8KEW`fJ=@_}{tz*>3&5d(k>1b6x*DJo=*R z6XCh=FT%5P-1;8w|0UP2;{NBl{ypw5{HNT%;@1C$`=_qI!Tpz^4Nrw%0ndfs0*}vk``i!Dg#QX&2>&xYS>*QlA9z*x z-uogS7Q6LB;HmJF;JNTK;BklBXE8hzei^(Fej_~Tbo<-`uL^$}9(B3(1w0l0K0Fsb zU_V-i_yV`jV0b3{cz7XvHazKe`T&CDfTzOmhUdbcg2%mXp8}o<{{UVH zuiKy2Az9+~83L~gPvFr~xBg6cD!c=p3ttJ3zwGw88J-EhA6^Jw4^Ni4eO`lCg?|i> zmb>-)A3*Dn3a^Lf!l%IF71U=+M2~aenec9SA^Zw>@(*sGo8eXA_rjwK-TG(XsqjC+ zbKxJtFUCcF^d3Qzvg?Q;>lD*T)9=nA*~PIxN( zadjUI_mWcybN(i6eS^2v3FYc?j}B_+WTd_;K)D_^I$hcso40)}7BK@L2e2cq04` zcq;r+cqaUJ@T%}l@Lc##pTY4Ud=NbPnmhl|@L2c^cp`irJQcnio(W$CuL{2%o(q2% zUI>349<6fc{}wzJzTF^NheY^5cq)82JQF?*UKL(}=fao53*pzmqwC!He;*zTe+Zrk ze-54se-oYw@Bdj^hpO;_@Lc!^cp>~`c=UC5{`26m@D=bx_;v79_*!@-Jcn0>Z-nQ< zH^B?xJIAyR(Kp=r$M9JAICvtw37!gXhiAewcolv`M32?*Liio<`1-^aa{Z(5RQN`C zRrovbLii4c(mKT7Orr9^{SSes!bifZ!l%Ov;T7(`+U>uT`wPE@`wPF7`wRaW_y3mL z|5@%Y{0;6e{1fgkeE-9+K5N|mN5fO$li*e1UxXLJySe{AyZx`^{=%!=U-$#uU-)|N ze}miqRqikRBknJJpTlV#3gJWH@r`c(3Gh_-TzFOZ1>9fw72N;ZZvR`jzwigRzwlpk zf8nol|C`+YpKyQS2bdG2{Quik;q~xB_+)r|v)lhm@KpE`?l1fr?l1iN-2WE0|3lng z`19Of_}koH_zr_{{8!!npMf{Q_l@W=3f?9B3-DFK=fT$rUk=|Od=-3?@U`%|@6bGX zJ~_NW_(ph>@OR-|!goB9)?tXf-vZwte2=4O9X1Ic46plM5|s~L{}bR1!cT`c311BF5`H;+mGGP3>xAD2 z-yr-~@J+&Bh1cEc&i`Y0gYW}}&^j~;KL*| zgRc_)Hav%~F~@HC*nTLz-t_jwK4(7|9<6nK1iUJIIz0J-Tc5%U;mhFJ58e7z@c2ir zuZ8ErAAzTLxb-iCfEy1CFM3h<@(+G4QJJY4GGBx4s!( z2wwru9(L=$0goSX{SJ68{4sc%yY(-@qhGkb1zr_CpdQEnqi+3C@IrV3&wlCFpAC;6 zbG;j$3%?4UKJM1v3Xh&}{ULZ2endo%e}@;s-+;$YQXj7W1fB}t?-*K#s_@Ul3*n9M z_$jylnebHjV(u^eGVU+@M(+Q#+y5T!FZ^llFTCLX!r$lq|LXQ1&_L^u3Lgxw3O^oR z2%im)pK<%2$NhzWh5HL%!~KQd#r^-y?f(S#7ydH$7rvSM3*T)xtwa1PxBp@ARQPy! zRd^G;5Wax>uXp=j%>9Lbllu$5gZm5rCHMce+y6!GFZ@03FMQV#v<`*v!{G4-xBs#5 zRQPG|s_^sRh44$^@o(JzH^5Wj_rR;d{}o;c{}cCr*6sf{?k{}rk;n((L*a$+3Gn#e z-TrgoDZCodqYEBANA>J0;Z@<^h9}Rv_4mLF;ZMP{7u@<+;PG!=-we-%?>Y+ku+gnQ z6dwJ~^>Og3@LBNWMYp~UUI@Pkp8ejfzaAdHC0~Y@8HoZu5W@@h3_<) z)*<3_NP zPr{@3T>k^SD*SzT^50ZHH=@TL<7geK!ViZ>o89{H@KpFLcrLsZ9&d5``~y4_ejU6J zemgw*tJ~*ccvblG@aTQF{w;Vae7o_q4!Q7w@c09_kGaGM{l2~MY4AdL1)hB9_E`$A z3cm&({mrev6`l(J89W#MEIj@nx6d2!On7uGy{Sa>RYCOi|~2CoXg7@iAX4KIZM7#5(3qJ~;2~Xg; z@U!93;cowK?l1f*?l1gS?l1fy?tg^a{{`+Z{9W!ZeCLzt_2$A4g-3(k{>Q=-;j`hH z@I~BT_~qRHNVosZ@FDQskz)_T#|eK0K27+?@D$#JK7+nMuXi1MU-+@`0^Z(_Hq3>m zLuj7-{~wmZb9jzEtKr$_sJ;Py57)!5hCj>whf@9F@OR)<_#F6v88rXs^Hjedd?-AI zC-9TuDZCEe2G2zON_Z~nzY8zm=Jc_TN8t^_Xg+(xUxBA^uKyUmPSg)PgmJ@q%!vybQC(J|y)zXhH&xb=I_r1@9j zTt5!)3wR9Q zein|a(bR{JlOy1D@a<8bz+?Em@DyIakA`2!^<$|2)$nh_b2uOW55l9dRL|?P5#9vn z_1O&1ME$;ILCU`mZV>ei@Ms+MZ@_$-;0^HI;fvr2Jb_;g&){|NweYH_e+piR`ai>? z@iZUqzx}B+{{+tcV|WTT!|kIHz7Ed$b}qaS^_RdKj-~x_{kOS4oclk-{YCwY+#fy) z^VtHAkE8wr;d`Bi*9GVLVem}UPlH!Q{d{;K>Mwyu$J2ff!G3Rm$M6C0`{50u{x|R@ zQU5kP744wKA(CcbIpR3_1oX?}%;H%(# z{N(T|d~fu55&j^Y^L7iofOC%3&7s%Za3alz`wWGra6Wz}!E-q0!@2NHqR%pT-AUA+ z=l^wh4Br>?zti|Oujh&SBT)Z@`C8^f7yLkY0lxyi3;ZMa8sP`_qdseekAgoaya~Pm z&gaE>@J+%mgV!aEb|zeZGkhp~N6ho5@CM;8z{d!G4}QGx+Vwo)e7@AK=PA5)Jx}4a z>v_TlVVv;;VUC&c^?RuV*Xg&%0+=uxj!fV&_6yDE_ z^PShfFz0(ebN%OKGpRq?N58hdpZ9vszCOP<^-;8sx-RrvwvWF4^A^<0>r3x^df7)` zr}|*y{UY-&rOjnQ?J?Z=-sXD6n}#LU`eRF@^;%i&n>ohg+Ow_Syl7otU%D&M=ThT! z(LvENF`p{~^~YJ)*XzD1Q2$!Me-iMG#>@H0>tnwfsQ;UB-#YAahFSgo2Sr`tb?sle z*#lo!oIl47HeRlOhV^g7lD=-<-#T;M>9wNID|S9xuV+3K^`lLnvRSE zF2o0mW2}3w4?n-Vx2JbWTU-5nbG`qQC!SWBF@5%&N+oJ(?QUJLu&1}RyVAS3GT+?% zv(?S+J;cUh|?#i@8;0Po;UuvS@zi;;u!ly{#?vV@HoK?;+qRsb7SP;{#z`Rw@l`n z5qR&v=D!aI-J31A&D_5yxUIbJFx}f@a?66&o~G9B2_5D9%3!JoK$Z0yA+sI&&eF@W`xe-`?Xj4x8arcAx3di4f>8fjhtMv{L*L$`ygW!$e{7|*S5cW%9Hu(&^PS!wPILbnvQm9=M7S$isOn`mz%sqWC@x#g?5 zEzoFvvtOg0`*Ruf-;QxOZcr^ILANDTvl#B*q5mGDo*P@4Y0%xfb!UGMy7{uIrdup( z_V3bnqfIjt|NZgk24cFky??o8f0L2^iO`J-Rg=;Fx7>F--*N%{z3B#Cs(0X?d~|O+ zRUNoJ6y01&ReNvGRnBmPf3fJE-Kxzf{~C_-H^HrvRTuAV%gf2oolRAJ@Gg#l6{DM- zsy4p6qS-geKl|W)!U9V?GH`4R_uYKB-0yh*u{1L9mXx|N z!%3;l3Z)q zZQh?)Rr9Sf#ph@`b5u3LNqbN4GX0f6)f7&e{kx=aQq?wBlu|e;rt?j+zX^qts;2WtF@=+23Ma)B zPKqg<6w|4um_9ivrf^bBXO3collH)3Q8=k`3Ma)BPKpsu+5?M=a8mUMC+&e1qi|B? z6i$i}PRbEZ+5=0Ba8mUMC+!qY$`MY=5l+exPReaKsaq}Euuy8lNvRDdr8bBb;v$?>J;F(Q zV8tk$R5^u{VuX`&gp>Bb5+j^cJ;F&lg_ClGlX8TUa)gs|8&2aR@z;JE7D{b6DYfCG z)P|E%3Mb9}{ZTlnY8xy{ZBi(uaMJAWLE)sTDV#L>cS+%-s%@?)rEpSA=bL7K6AC9) zP3Mnd3Ma)BPKqg<6jL}Urc+HZg_B|mC&hH;C`LGG4=fgilPafhQcU5b7~!Nnu(${( zRgZAe9#}C7Csj`2q!{6(9O0xru*3)_RgZAePT`~+;iMelq#WU-+=kQe25&lPw(+Fd z=96X{P?{;BJZ>Y(7>$5k)@q7OFM;@c1kVnbP{T(+|o|LrJYVI?T9YVhS17UcdVc?}WdANH0M#z( zMAGbED#`*?O<}3o|8gioRW+TuiYfRMQ~GEQ9BclWAS6{6M40x#yNokj*HhwY4=e$K zP}fsXC`UeO4;^2DcN?*y`%u;?M?Pr}90*7!Rd0_}_jjzy1GtPVrS^bSYQssXeYcg` za8hay7^OCxlu|fp_WTZMEu3_<|MgKg>1zKgq>mfA+W%_kuvOLc(M_{|sYm!%)%S~d zwQy3sDV#L>d(+{ns_CrK?0@leOsZ=7prx43OwIl^p>R^w6i%A`6Qs{3sv6;>oqp(P z54_6=CtV*{MtmgF_4Hfr+9{lrBb>BTIB5^O+XyFJPvN8-;iNrqARwGny$vV#cdR&^ zl-i?1sXcX-+CyEb4JW1cfKh70NhyVsW*bhL{V$Jx?_F2>Um$&Q($)T#NS~ZkH66B^ z{S%~vM_2oIN#Ufb>64RY|1Rm1ld7h}RkMGo=#!JGrejjG|K(6PscQP|pPY0(g_ClGllIW@6?nH1PPz|;lX8TU_P~LF za8mX5NOgb5io;2%Js_3Za8hdDZKXDxl-dJEsSPKk6i%9LIBE93JPIdW?SFw3PP*Fv z5-FTiH66B^{S%~vM_2oIN#UfbDV#L>cS+%-s_Agm>|ZJhCsj?yq-Ouip)*reQ#dK6 za8gX+q&aY``DcP~Qe6;E+5_)0!b#UtIB5?o0m4bwQ#dI{IB5?ZUx9ZU;iUUeI4MUs zX%8F-2q#r97&x4i+5=Ll4JW1c-BxPDNvSq zHHDL63Ma)BPMQP9ntvt;C)EYvq&@I1Bb;Br@fCQt5l*@f zg_ClGllH)YfN)av_DB`~?#Jn**&dRbZ9ZwX@3>~0P@3&wquFMZW(p~f+m!Nn;Du67 zdFlf%m6FO+A9%5pRl1%IV~+>sNr#iCKCoX3EL~5D(B1=+aKvrJcgdN^^akXZ zXG8GF3mpQ8GEXbYGQ9y|=GhQBJP>DQM4yYtG~cV`;toV|iO>E&0P> zc&)~L%6`Xr=S=$zkEQ*N_m1Ulp*d4;|5)A@8e99J5`MwkIC81GDe#T1ZTysd`zMZx zjsKL@Hor`>jeUnl(>W6uUEAoLxxHKzov~`yeYS0Ttmka3jSZZQ_9|5LFKpiZ;$Npi z`=z(TzhB-K8q5E?*t=i+&+_0{J1IA(Nk%b4JnvB53lf?LK1x0vH5 zG;I^^o=x^I58hRPOU% zjw;jVoKo3({nR<9Of0XSI;VNwqSmNuNpFv+Zf$AqZI0T^C02V{#isJwjq}g1%x^!x z($>6i(blcyRaWgh?CdM$1yZ+ev~#GGUFq77QCnB{!j9fHS+QVoX9rc-m22tgth6_G zw3t~|rq41PS{8Oxmh`lmh1>d?%Y`$~=k@fUce(3mewSH|?$!$`Q>U$n+B&;h1skSe7FYHyTU{;Xd-*RdB!nDr9c685})HJbzL!`XusyR$r zyPM5bYAcOroMjG{D5~#SzPPt}p849_O<&vjJF`Bm-Ca?AM`v$qedC1bNB1@_z_SG% zOX}w>S-7a>=!Gp&efg}txu-pr#8i=uG=zW;+o^9L@&%ul28vc@}^|9JeI z{)u@OMRNeLeYW)vzJ4^zaPv*y@xA>MyQvrBkFd|S{vpRtGMoPT$tRt>|26#+Tf7Fq z^WVX06!G<<@idxgzS+(E$KxODpO|M+^dKO{3oh>uP=3qf%@xV*!(7feD(^|b<2P=X zSl?Kpd0a|gYJbZ0JJ)Raq|f~4ZlBoNxp<+xAD%z&hrgb0sz2^Cei_Cu!}tc#1)ZMiqSj46c{2{|6Y)?;l^MJ;Dt_hQ;OV zwmy=r-`el)Hh-2CJbu_Ijn;>qLgVM8Fa{rGQ>pQ+3-?4EtbA9!xFd1j8a|Ks>Sn%Z(ty#E;E*DV zFn$QeZ=jb^JHC1Td>pJ1`~RRq^Z%ei1G(Om*#|%8ukRY|JOA2!5>gu9j&b~j$MM$> z#CX1sKs(0sJmq+P{;~O{?8UD?!*%(WVf+v-#Mf9n-_A_4oN0q_9zR+*y($`0ZrUB= zMOkzw_MeIkJf8XB!1z6ysq*MfuB5MW{854N$Ks8DRtykNqtSu!yJO%x9Q>Gu9N&oX za{d1HTdKVMO#l43&t7ITzju8rpL>-OVFnil_Fr!1?C3jw?J=ZDh4gUq2) {printf("Illegal R %d\n",R); abort();} - // system("mkdir -p ldpc_gen_files"); + // system("mkdir -p ../ldpc_gen_files"); char fname[50]; sprintf(fname,"../ldpc_gen_files/nrLDPC_cnProc_BG1_Z%d_%s_AVX512.c",Z,ratestr[R]); FILE *fd=fopen(fname,"w"); - if (fd == NULL) {printf("Cannot create %s\n");abort();} + if (fd == NULL) {printf("Cannot create \n");abort();} fprintf(fd,"#include \n"); fprintf(fd,"#include \n"); @@ -92,7 +91,7 @@ void nrLDPC_cnProc_BG1_generator_AVX512(uint16_t Z,int R) //p_cnProcBufRes = (__m512i*) &cnProcBufRes[lut_startAddrCnGroups[0]]; // Loop over every BN - int iprime=0; + for (j=0; j<3; j++) { // Set of results pointer to correct BN address @@ -178,7 +177,6 @@ void nrLDPC_cnProc_BG1_generator_AVX512(uint16_t Z,int R) //p_cnProcBufRes = (__m512i*) &cnProcBufRes[lut_startAddrCnGroups[1]]; // Loop over every BN - int iprime=0; for (j=0; j<4; j++) { // Set of results pointer to correct BN address @@ -243,7 +241,7 @@ void nrLDPC_cnProc_BG1_generator_AVX512(uint16_t Z,int R) //p_cnProcBufRes = (__m512i*) &cnProcBufRes[lut_startAddrCnGroups[1]]; // Loop over every BN - int iprime=0; + for (j=0; j<5; j++) { // Set of results pointer to correct BN address @@ -308,7 +306,7 @@ void nrLDPC_cnProc_BG1_generator_AVX512(uint16_t Z,int R) //p_cnProcBufRes = (__m512i*) &cnProcBufRes[lut_startAddrCnGroups[1]]; // Loop over every BN - int iprime=0; + for (j=0; j<6; j++) { // Set of results pointer to correct BN address @@ -375,7 +373,7 @@ void nrLDPC_cnProc_BG1_generator_AVX512(uint16_t Z,int R) //p_cnProcBufRes = (__m512i*) &cnProcBufRes[lut_startAddrCnGroups[1]]; // Loop over every BN - int iprime=0; + for (j=0; j<7; j++) { // Set of results pointer to correct BN address @@ -443,7 +441,7 @@ void nrLDPC_cnProc_BG1_generator_AVX512(uint16_t Z,int R) //p_cnProcBufRes = (__m512i*) &cnProcBufRes[lut_startAddrCnGroups[1]]; // Loop over every BN - int iprime=0; + for (j=0; j<8; j++) { // Set of results pointer to correct BN address @@ -512,7 +510,7 @@ void nrLDPC_cnProc_BG1_generator_AVX512(uint16_t Z,int R) //p_cnProcBufRes = (__m512i*) &cnProcBufRes[lut_startAddrCnGroups[1]]; // Loop over every BN - int iprime=0; + for (j=0; j<9; j++) { // Set of results pointer to correct BN address @@ -582,7 +580,7 @@ void nrLDPC_cnProc_BG1_generator_AVX512(uint16_t Z,int R) //p_cnProcBufRes = (__m512i*) &cnProcBufRes[lut_startAddrCnGroups[1]]; // Loop over every BN - int iprime=0; + for (j=0; j<10; j++) { // Set of results pointer to correct BN address @@ -655,7 +653,7 @@ void nrLDPC_cnProc_BG1_generator_AVX512(uint16_t Z,int R) //p_cnProcBufRes = (__m512i*) &cnProcBufRes[lut_startAddrCnGroups[1]]; // Loop over every BN - int iprime=0; + for (j=0; j<19; j++) { // Set of results pointer to correct BN address diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx512/cnProc_gen_avx512.h b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx512/cnProc_gen_avx512.h deleted file mode 100644 index 1c6b4c381f..0000000000 --- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx512/cnProc_gen_avx512.h +++ /dev/null @@ -1,6 +0,0 @@ -#ifndef NRLDPC_CN_GEN -#define NRLDPC_CN_GEN - -void nrLDPC_cnProc_BG1_generator_AVX512(uint16_t Z,int R); - -#endif diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx512/main.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx512/main.c index b7cad86410..99983a1ad0 100644 --- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx512/main.c +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/generator_avx512/main.c @@ -1,16 +1,24 @@ + #include #include -//#include "../nrLDPCdecoder_defs.h" #include "../../nrLDPC_types.h" #include "../../nrLDPC_init.h" #include "../../nrLDPC_bnProc.h" -#include "cnProc_gen_avx512.h" - -int main(int argc, char *argv []) +#define NB_Z 51 +void nrLDPC_cnProc_BG1_generator_AVX512(uint16_t,int); +int main() { - - // Z=384, R=1/3 - nrLDPC_cnProc_BG1_generator_AVX512(384,0); - + uint16_t Z[NB_Z]={2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,18,20,22,24,26,28,30,32,36,40,44,48,52,56,60,64,72,80,88,96,104,112,120,128,144,160,176,192,208,224,240,256,288,320,352,384}; + + + for(int i=0; i +#include +void nrLDPC_cnProc_BG1_Z104_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<4;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<17;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<17;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<17;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<17;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<59;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<59;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<59;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<59;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<59;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<26;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<26;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<26;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<26;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<26;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<26;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<17;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<17;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<17;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<17;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<17;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<17;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<17;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z10_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z10_13_AVX2.c new file mode 100644 index 0000000000..a2c5cbf268 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z10_13_AVX2.c @@ -0,0 +1,2334 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z10_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z112_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z112_13_AVX2.c new file mode 100644 index 0000000000..2af85e2fc3 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z112_13_AVX2.c @@ -0,0 +1,2334 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z112_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<4;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<63;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<63;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<63;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<63;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<63;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<28;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<28;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<28;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<28;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<28;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<28;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z11_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z11_13_AVX2.c new file mode 100644 index 0000000000..666762afcd --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z11_13_AVX2.c @@ -0,0 +1,2334 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z11_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z120_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z120_13_AVX2.c new file mode 100644 index 0000000000..f4f40c07a0 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z120_13_AVX2.c @@ -0,0 +1,2334 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z120_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<4;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<19;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<19;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<19;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<19;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<68;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<68;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<68;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<68;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<68;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<19;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<19;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<19;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<19;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<19;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<19;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<19;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z128_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z128_13_AVX2.c new file mode 100644 index 0000000000..095d2f743d --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z128_13_AVX2.c @@ -0,0 +1,2334 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z128_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<4;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<72;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<72;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<72;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<72;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<72;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<32;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<32;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<32;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<32;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<32;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<32;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z12_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z12_13_AVX2.c new file mode 100644 index 0000000000..783e09b241 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z12_13_AVX2.c @@ -0,0 +1,2334 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z12_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z13_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z13_13_AVX2.c new file mode 100644 index 0000000000..ab811e3df9 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z13_13_AVX2.c @@ -0,0 +1,2334 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z13_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z144_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z144_13_AVX2.c new file mode 100644 index 0000000000..e770e21511 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z144_13_AVX2.c @@ -0,0 +1,2334 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z144_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<5;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<23;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<23;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<23;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<23;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<81;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<81;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<81;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<81;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<81;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<36;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<36;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<36;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<36;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<36;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<36;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<23;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<23;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<23;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<23;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<23;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<23;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<23;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z14_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z14_13_AVX2.c new file mode 100644 index 0000000000..03fa3debac --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z14_13_AVX2.c @@ -0,0 +1,2334 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z14_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z15_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z15_13_AVX2.c new file mode 100644 index 0000000000..079d3cc599 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z15_13_AVX2.c @@ -0,0 +1,2334 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z15_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z160_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z160_13_AVX2.c new file mode 100644 index 0000000000..2a830f13ee --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z160_13_AVX2.c @@ -0,0 +1,2334 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z160_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<5;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<25;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<25;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<25;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<25;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<90;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<90;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<90;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<90;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<90;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<40;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<40;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<40;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<40;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<40;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<40;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<25;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<25;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<25;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<25;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<25;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<25;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<25;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z16_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z16_13_AVX2.c new file mode 100644 index 0000000000..63b584b788 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z16_13_AVX2.c @@ -0,0 +1,2334 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z16_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z176_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z176_13_AVX2.c new file mode 100644 index 0000000000..36025072dc --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z176_13_AVX2.c @@ -0,0 +1,2334 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z176_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<6;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<28;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<28;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<28;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<28;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<99;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<99;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<99;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<99;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<99;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<44;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<44;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<44;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<44;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<44;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<44;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<28;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<28;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<28;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<28;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<28;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<28;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<28;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z18_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z18_13_AVX2.c new file mode 100644 index 0000000000..ce4b9f2519 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z18_13_AVX2.c @@ -0,0 +1,2334 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z18_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z192_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z192_13_AVX2.c new file mode 100644 index 0000000000..b9bb165056 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z192_13_AVX2.c @@ -0,0 +1,2334 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z192_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<6;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<108;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<108;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<108;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<108;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<108;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<48;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<48;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<48;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<48;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<48;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<48;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z208_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z208_13_AVX2.c new file mode 100644 index 0000000000..d48382ffb7 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z208_13_AVX2.c @@ -0,0 +1,2334 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z208_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<7;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<33;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<33;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<33;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<33;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<117;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<117;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<117;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<117;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<117;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<52;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<52;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<52;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<52;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<52;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<52;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<33;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<33;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<33;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<33;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<33;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<33;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<33;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<26;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<26;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<26;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<26;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<26;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<26;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<26;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<26;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<26;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<26;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<26;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<26;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<26;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<26;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<26;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<26;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<26;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<26;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<26;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z20_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z20_13_AVX2.c new file mode 100644 index 0000000000..5ada89eb42 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z20_13_AVX2.c @@ -0,0 +1,2334 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z20_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z224_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z224_13_AVX2.c new file mode 100644 index 0000000000..9e91647b84 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z224_13_AVX2.c @@ -0,0 +1,2334 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z224_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<7;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<35;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<35;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<35;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<35;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<126;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<126;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<126;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<126;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<126;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<56;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<56;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<56;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<56;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<56;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<56;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<35;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<35;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<35;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<35;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<35;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<35;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<35;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<28;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<28;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<28;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<28;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<28;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<28;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<28;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<28;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<28;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<28;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<28;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<28;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<28;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<28;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<28;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<28;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<28;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<28;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<28;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z22_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z22_13_AVX2.c new file mode 100644 index 0000000000..8c0dce803b --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z22_13_AVX2.c @@ -0,0 +1,2334 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z22_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z240_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z240_13_AVX2.c new file mode 100644 index 0000000000..658e8adb65 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z240_13_AVX2.c @@ -0,0 +1,2334 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z240_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<8;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<38;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<38;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<38;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<38;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<135;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<135;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<135;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<135;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<135;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<60;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<60;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<60;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<60;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<60;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<60;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<38;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<38;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<38;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<38;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<38;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<38;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<38;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z24_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z24_13_AVX2.c new file mode 100644 index 0000000000..2d4f9adad7 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z24_13_AVX2.c @@ -0,0 +1,2334 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z24_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z256_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z256_13_AVX2.c new file mode 100644 index 0000000000..ac197a4268 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z256_13_AVX2.c @@ -0,0 +1,2334 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z256_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<8;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<40;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<40;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<40;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<40;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<144;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<144;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<144;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<144;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<144;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<64;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<64;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<64;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<64;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<64;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<64;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<40;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<40;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<40;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<40;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<40;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<40;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<40;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<32;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<32;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<32;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<32;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<32;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<32;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<32;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<32;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<32;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<32;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<32;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<32;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<32;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<32;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<32;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<32;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<32;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<32;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<32;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z26_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z26_13_AVX2.c new file mode 100644 index 0000000000..e08c8256e0 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z26_13_AVX2.c @@ -0,0 +1,2334 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z26_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z288_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z288_13_AVX2.c new file mode 100644 index 0000000000..e99810238a --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z288_13_AVX2.c @@ -0,0 +1,2334 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z288_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<9;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<45;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<45;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<45;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<45;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<162;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<162;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<162;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<162;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<162;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<72;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<72;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<72;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<72;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<72;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<72;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<45;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<45;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<45;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<45;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<45;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<45;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<45;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<36;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<36;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<36;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<36;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<36;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<36;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<36;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<36;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<36;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<36;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<36;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<36;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<36;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<36;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<36;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<36;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<36;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<36;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<36;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z28_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z28_13_AVX2.c new file mode 100644 index 0000000000..061abd44d1 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z28_13_AVX2.c @@ -0,0 +1,2334 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z28_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z2_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z2_13_AVX2.c new file mode 100644 index 0000000000..1ac0c975a5 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z2_13_AVX2.c @@ -0,0 +1,2334 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z2_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z30_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z30_13_AVX2.c new file mode 100644 index 0000000000..aec019ef12 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z30_13_AVX2.c @@ -0,0 +1,2334 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z30_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<17;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<17;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<17;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<17;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<17;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z320_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z320_13_AVX2.c new file mode 100644 index 0000000000..9497c1e624 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z320_13_AVX2.c @@ -0,0 +1,2334 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z320_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<10;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<50;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<50;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<50;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<50;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<180;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<180;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<180;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<180;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<180;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<80;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<80;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<80;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<80;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<80;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<80;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<50;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<50;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<50;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<50;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<50;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<50;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<50;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<40;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<40;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<40;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<40;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<40;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<40;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<40;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<40;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<40;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<40;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<40;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<40;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<40;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<40;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<40;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<40;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<40;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<40;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<40;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z32_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z32_13_AVX2.c new file mode 100644 index 0000000000..dde34cdf78 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z32_13_AVX2.c @@ -0,0 +1,2334 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z32_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z352_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z352_13_AVX2.c new file mode 100644 index 0000000000..e81985cafb --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z352_13_AVX2.c @@ -0,0 +1,2334 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z352_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<11;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<55;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<55;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<55;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<55;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<198;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<198;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<198;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<198;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<198;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<88;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<88;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<88;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<88;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<88;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<88;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<55;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<55;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<55;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<55;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<55;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<55;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<55;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<44;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<44;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<44;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<44;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<44;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<44;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<44;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<44;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<44;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<44;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<44;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<44;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<44;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<44;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<44;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<44;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<44;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<44;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<44;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z36_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z36_13_AVX2.c new file mode 100644 index 0000000000..386c29e5eb --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z36_13_AVX2.c @@ -0,0 +1,2334 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z36_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<2;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<21;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<21;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<21;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<21;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<21;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z384_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z384_13_AVX2.c new file mode 100644 index 0000000000..2608035e62 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z384_13_AVX2.c @@ -0,0 +1,2335 @@ +#include +#include + +void nrLDPC_cnProc_BG1_Z384_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<12;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<60;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<60;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<60;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<60;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<216;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<216;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<216;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<216;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<216;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<96;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<96;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<96;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<96;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<96;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<96;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<60;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<60;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<60;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<60;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<60;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<60;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<60;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<48;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<48;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<48;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<48;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<48;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<48;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<48;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<48;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<48;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<48;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<48;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<48;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<48;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<48;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<48;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<48;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<48;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<48;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<48;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z3_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z3_13_AVX2.c new file mode 100644 index 0000000000..6f5f7f4eb2 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z3_13_AVX2.c @@ -0,0 +1,2334 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z3_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z40_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z40_13_AVX2.c new file mode 100644 index 0000000000..4c8046fd72 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z40_13_AVX2.c @@ -0,0 +1,2334 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z40_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<2;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<23;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<23;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<23;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<23;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<23;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z44_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z44_13_AVX2.c new file mode 100644 index 0000000000..47df2aa74e --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z44_13_AVX2.c @@ -0,0 +1,2334 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z44_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<2;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<25;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<25;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<25;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<25;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<25;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z48_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z48_13_AVX2.c new file mode 100644 index 0000000000..dda20ab154 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z48_13_AVX2.c @@ -0,0 +1,2334 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z48_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<2;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<27;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<27;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<27;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<27;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<27;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z4_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z4_13_AVX2.c new file mode 100644 index 0000000000..b08efcf2e3 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z4_13_AVX2.c @@ -0,0 +1,2334 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z4_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z52_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z52_13_AVX2.c new file mode 100644 index 0000000000..6f9d2e7621 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z52_13_AVX2.c @@ -0,0 +1,2334 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z52_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<2;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<30;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z56_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z56_13_AVX2.c new file mode 100644 index 0000000000..2624915c8f --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z56_13_AVX2.c @@ -0,0 +1,2334 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z56_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<2;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<32;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<32;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<32;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<32;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<32;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<7;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z5_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z5_13_AVX2.c new file mode 100644 index 0000000000..c9179e1e46 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z5_13_AVX2.c @@ -0,0 +1,2334 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z5_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z60_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z60_13_AVX2.c new file mode 100644 index 0000000000..26a74d2f9f --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z60_13_AVX2.c @@ -0,0 +1,2334 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z60_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<2;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<34;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<34;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<34;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<34;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<34;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z64_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z64_13_AVX2.c new file mode 100644 index 0000000000..2f40269ead --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z64_13_AVX2.c @@ -0,0 +1,2334 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z64_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<2;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<36;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<36;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<36;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<36;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<36;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<16;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<8;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z6_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z6_13_AVX2.c new file mode 100644 index 0000000000..604cd0ae76 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z6_13_AVX2.c @@ -0,0 +1,2334 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z6_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z72_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z72_13_AVX2.c new file mode 100644 index 0000000000..7ae6302e64 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z72_13_AVX2.c @@ -0,0 +1,2334 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z72_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<3;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<41;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<41;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<41;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<41;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<41;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<18;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<9;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z7_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z7_13_AVX2.c new file mode 100644 index 0000000000..b8a0a9a373 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z7_13_AVX2.c @@ -0,0 +1,2334 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z7_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<4;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z80_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z80_13_AVX2.c new file mode 100644 index 0000000000..c52d2675e9 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z80_13_AVX2.c @@ -0,0 +1,2334 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z80_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<3;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<45;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<45;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<45;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<45;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<45;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<20;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<13;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<10;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z88_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z88_13_AVX2.c new file mode 100644 index 0000000000..bd3c552192 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z88_13_AVX2.c @@ -0,0 +1,2334 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z88_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<3;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<50;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<50;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<50;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<50;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<50;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<22;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<14;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<11;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z8_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z8_13_AVX2.c new file mode 100644 index 0000000000..e17a44c1bd --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z8_13_AVX2.c @@ -0,0 +1,2334 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z8_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<5;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z96_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z96_13_AVX2.c new file mode 100644 index 0000000000..09a3824190 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z96_13_AVX2.c @@ -0,0 +1,2334 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z96_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<3;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<54;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<54;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<54;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<54;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<54;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<24;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<15;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<12;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z9_13_AVX2.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z9_13_AVX2.c new file mode 100644 index 0000000000..008fdf92c1 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/avx2/nrLDPC_cnProc_BG1_Z9_13_AVX2.c @@ -0,0 +1,2334 @@ +#include +#include +void nrLDPC_cnProc_BG1_Z9_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m256i ymm0, min, sgn,ones,maxLLR; + ones = _mm256_set1_epi8((char)1); + maxLLR = _mm256_set1_epi8((char)127); + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[0+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[24+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[12+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[25+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[13+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i+=2) { + ymm0 = ((__m256i*)cnProcBuf)[0+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[12+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[24+i] = _mm256_sign_epi8(min, sgn); + ymm0 = ((__m256i*)cnProcBuf)[1+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[13+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[25+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[36+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[96+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[156+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[36+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[96+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[156+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[216+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[276+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[492+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[708+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1140+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[924+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<6;i++) { + ymm0 = ((__m256i*)cnProcBuf)[276+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[492+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[708+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[924+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1140+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1356+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1452+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1548+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1644+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1836+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1740+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<3;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1356+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1452+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1548+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1644+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1740+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1836+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1932+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[1992+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2052+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2112+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2172+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2292+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2232+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[1932+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[1992+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2052+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2112+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2172+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2232+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2292+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2352+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2376+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2400+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2424+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2448+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2472+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2520+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2496+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2352+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2376+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2400+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2424+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2448+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2472+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2496+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2520+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2544+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2568+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2592+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2616+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2640+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2664+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2688+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2736+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2712+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2544+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2568+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2592+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2616+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2640+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2664+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2688+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2712+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2736+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2760+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2772+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2784+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2796+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2808+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2820+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2832+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2844+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2868+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2856+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<1;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2760+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2772+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2784+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2796+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2808+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2820+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2832+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2844+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2856+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2868+i] = _mm256_sign_epi8(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2880+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2928+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[2976+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3024+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3072+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3120+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3168+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3216+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3264+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3312+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3360+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3408+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3456+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3504+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3552+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3600+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3648+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3744+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3696+i] = _mm256_sign_epi8(min, sgn); + } + for (int i=0;i<2;i++) { + ymm0 = ((__m256i*)cnProcBuf)[2880+i]; + sgn = _mm256_sign_epi8(ones, ymm0); + min = _mm256_abs_epi8(ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2928+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[2976+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3024+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3072+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3120+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3168+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3216+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3264+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3312+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3360+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3408+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3456+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3504+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3552+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3600+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3648+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + ymm0 = ((__m256i*)cnProcBuf)[3696+i]; + min = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0)); + sgn = _mm256_sign_epi8(sgn, ymm0); + min = _mm256_min_epu8(min, maxLLR); + ((__m256i*)cnProcBufRes)[3744+i] = _mm256_sign_epi8(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z104_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z104_13_AVX512.c new file mode 100644 index 0000000000..a80f3fb280 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z104_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z104_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<5;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<18;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<18;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<18;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<18;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<60;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<60;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<60;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<60;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<60;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<27;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<27;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<27;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<27;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<27;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<27;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<18;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<18;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<18;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<18;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<18;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<18;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<18;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z10_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z10_13_AVX512.c new file mode 100644 index 0000000000..b46f3f2e20 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z10_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z10_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z112_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z112_13_AVX512.c new file mode 100644 index 0000000000..14de356cc0 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z112_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z112_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<5;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<64;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<64;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<64;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<64;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<64;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z11_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z11_13_AVX512.c new file mode 100644 index 0000000000..aeba3ddd1f --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z11_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z11_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z120_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z120_13_AVX512.c new file mode 100644 index 0000000000..71bc1db2bd --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z120_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z120_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<5;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<20;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<20;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<20;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<20;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<69;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<69;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<69;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<69;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<69;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<20;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<20;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<20;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<20;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<20;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<20;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<20;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z128_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z128_13_AVX512.c new file mode 100644 index 0000000000..15edfb7647 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z128_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z128_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<5;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<73;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<73;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<73;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<73;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<73;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<33;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<33;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<33;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<33;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<33;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<33;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z12_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z12_13_AVX512.c new file mode 100644 index 0000000000..09610a25e7 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z12_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z12_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z13_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z13_13_AVX512.c new file mode 100644 index 0000000000..96e108ac27 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z13_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z13_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z144_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z144_13_AVX512.c new file mode 100644 index 0000000000..449becf031 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z144_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z144_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<6;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<24;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<24;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<24;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<24;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<82;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<82;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<82;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<82;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<82;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<24;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<24;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<24;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<24;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<24;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<24;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<24;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z14_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z14_13_AVX512.c new file mode 100644 index 0000000000..0145645d66 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z14_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z14_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z15_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z15_13_AVX512.c new file mode 100644 index 0000000000..c301777ab6 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z15_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z15_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z160_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z160_13_AVX512.c new file mode 100644 index 0000000000..bd90abe1ed --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z160_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z160_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<6;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<26;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<26;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<26;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<26;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<91;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<91;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<91;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<91;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<91;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<26;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<26;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<26;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<26;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<26;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<26;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<26;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z16_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z16_13_AVX512.c new file mode 100644 index 0000000000..4108cc350d --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z16_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z16_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z176_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z176_13_AVX512.c new file mode 100644 index 0000000000..2b8c34cfcd --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z176_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z176_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<7;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<100;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<100;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<100;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<100;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<100;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<45;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<45;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<45;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<45;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<45;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<45;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z18_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z18_13_AVX512.c new file mode 100644 index 0000000000..79fd7bb3fc --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z18_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z18_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z192_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z192_13_AVX512.c new file mode 100644 index 0000000000..fa57e497b2 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z192_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z192_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<7;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<109;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<109;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<109;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<109;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<109;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<49;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<49;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<49;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<49;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<49;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<49;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z208_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z208_13_AVX512.c new file mode 100644 index 0000000000..6533824d04 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z208_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z208_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<8;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<34;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<34;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<34;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<34;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<118;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<118;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<118;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<118;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<118;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<53;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<53;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<53;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<53;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<53;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<53;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<34;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<34;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<34;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<34;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<34;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<34;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<34;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<27;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<27;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<27;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<27;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<27;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<27;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<27;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<27;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<27;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<27;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<27;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<27;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<27;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<27;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<27;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<27;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<27;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<27;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<27;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z20_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z20_13_AVX512.c new file mode 100644 index 0000000000..b64ec809d7 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z20_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z20_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z224_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z224_13_AVX512.c new file mode 100644 index 0000000000..96bd8f328b --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z224_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z224_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<8;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<36;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<36;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<36;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<36;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<127;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<127;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<127;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<127;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<127;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<57;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<57;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<57;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<57;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<57;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<57;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<36;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<36;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<36;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<36;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<36;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<36;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<36;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<29;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z22_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z22_13_AVX512.c new file mode 100644 index 0000000000..071aaa7acc --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z22_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z22_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z240_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z240_13_AVX512.c new file mode 100644 index 0000000000..53a9cdbdf4 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z240_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z240_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<9;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<39;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<39;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<39;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<39;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<136;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<136;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<136;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<136;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<136;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<61;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<61;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<61;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<61;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<61;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<61;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<39;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<39;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<39;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<39;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<39;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<39;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<39;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z24_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z24_13_AVX512.c new file mode 100644 index 0000000000..a34658b5ec --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z24_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z24_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z256_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z256_13_AVX512.c new file mode 100644 index 0000000000..c7a646abae --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z256_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z256_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<9;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<145;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<145;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<145;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<145;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<145;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<65;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<65;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<65;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<65;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<65;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<65;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<33;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<33;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<33;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<33;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<33;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<33;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<33;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<33;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<33;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<33;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<33;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<33;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<33;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<33;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<33;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<33;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<33;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<33;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<33;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z26_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z26_13_AVX512.c new file mode 100644 index 0000000000..bd776e8af1 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z26_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z26_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z288_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z288_13_AVX512.c new file mode 100644 index 0000000000..90553112b0 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z288_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z288_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<10;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<46;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<46;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<46;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<46;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<163;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<163;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<163;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<163;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<163;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<73;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<73;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<73;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<73;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<73;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<73;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<46;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<46;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<46;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<46;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<46;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<46;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<46;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z28_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z28_13_AVX512.c new file mode 100644 index 0000000000..aca2ba32eb --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z28_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z28_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z2_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z2_13_AVX512.c new file mode 100644 index 0000000000..92237b43f2 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z2_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z2_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z30_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z30_13_AVX512.c new file mode 100644 index 0000000000..b08797b2c3 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z30_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z30_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<18;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<18;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<18;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<18;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<18;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z320_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z320_13_AVX512.c new file mode 100644 index 0000000000..09f4b52d2f --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z320_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z320_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<11;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<51;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<51;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<51;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<51;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<181;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<181;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<181;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<181;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<181;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<81;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<81;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<81;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<81;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<81;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<81;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<51;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<51;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<51;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<51;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<51;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<51;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<51;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<41;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z32_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z32_13_AVX512.c new file mode 100644 index 0000000000..a09cfac995 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z32_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z32_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z352_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z352_13_AVX512.c new file mode 100644 index 0000000000..d9e160a715 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z352_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z352_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<12;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<56;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<56;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<56;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<56;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<199;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<199;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<199;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<199;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<199;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<89;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<89;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<89;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<89;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<89;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<89;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<56;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<56;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<56;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<56;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<56;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<56;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<56;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<45;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<45;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<45;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<45;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<45;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<45;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<45;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<45;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<45;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<45;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<45;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<45;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<45;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<45;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<45;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<45;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<45;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<45;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<45;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z36_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z36_13_AVX512.c new file mode 100644 index 0000000000..25b58a5900 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z36_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z36_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<3;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<22;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<22;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<22;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<22;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<22;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z384_13.h b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z384_13.h deleted file mode 100644 index e48b8bc26d..0000000000 --- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z384_13.h +++ /dev/null @@ -1,5 +0,0 @@ -#ifndef NR_CN_PROC_BG1_OPTIM -#define NR_CN_PROC_BG1_OPTIM - void nrLDPC_cnProc_BG1_Z384_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes); - void nrLDPC_cnProc_BG1_Z384_13_AVX2(int8_t* cnProcBuf,int8_t* cnProcBufRes); -#endif diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z384_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z384_13_AVX512.c new file mode 100644 index 0000000000..90743f4d94 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z384_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z384_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<13;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<61;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<61;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<61;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<61;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<217;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<217;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<217;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<217;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<217;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<97;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<97;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<97;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<97;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<97;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<97;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<61;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<61;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<61;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<61;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<61;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<61;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<61;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<49;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<49;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<49;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<49;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<49;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<49;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<49;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<49;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<49;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<49;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<49;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<49;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<49;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<49;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<49;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<49;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<49;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<49;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<49;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z3_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z3_13_AVX512.c new file mode 100644 index 0000000000..68d316935c --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z3_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z3_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z40_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z40_13_AVX512.c new file mode 100644 index 0000000000..39bd657832 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z40_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z40_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<3;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<24;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<24;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<24;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<24;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<24;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z44_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z44_13_AVX512.c new file mode 100644 index 0000000000..aa1e643497 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z44_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z44_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<3;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<26;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<26;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<26;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<26;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<26;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z48_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z48_13_AVX512.c new file mode 100644 index 0000000000..5638fe34d4 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z48_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z48_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<3;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<28;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<28;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<28;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<28;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<28;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z4_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z4_13_AVX512.c new file mode 100644 index 0000000000..268c1feda5 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z4_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z4_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z52_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z52_13_AVX512.c new file mode 100644 index 0000000000..bbb23c68e1 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z52_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z52_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<3;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<31;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z56_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z56_13_AVX512.c new file mode 100644 index 0000000000..697578fb91 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z56_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z56_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<3;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<33;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<33;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<33;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<33;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<33;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<8;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z5_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z5_13_AVX512.c new file mode 100644 index 0000000000..9ecfe8253e --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z5_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z5_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z60_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z60_13_AVX512.c new file mode 100644 index 0000000000..7388cfc93c --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z60_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z60_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<3;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<35;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<35;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<35;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<35;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<35;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z64_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z64_13_AVX512.c new file mode 100644 index 0000000000..344c581d07 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z64_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z64_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<3;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<37;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<17;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<9;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z6_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z6_13_AVX512.c new file mode 100644 index 0000000000..f36090f3c5 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z6_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z6_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z72_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z72_13_AVX512.c new file mode 100644 index 0000000000..7cd843079a --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z72_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z72_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<4;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<42;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<42;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<42;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<42;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<42;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<19;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<10;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z7_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z7_13_AVX512.c new file mode 100644 index 0000000000..b6b2217da5 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z7_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z7_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<5;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z80_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z80_13_AVX512.c new file mode 100644 index 0000000000..4270e81f94 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z80_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z80_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<4;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<46;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<46;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<46;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<46;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<46;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<21;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<14;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<11;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z88_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z88_13_AVX512.c new file mode 100644 index 0000000000..e57da338bb --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z88_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z88_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<4;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<51;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<51;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<51;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<51;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<51;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<23;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<15;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<12;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z8_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z8_13_AVX512.c new file mode 100644 index 0000000000..0048bf497c --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z8_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z8_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<6;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z96_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z96_13_AVX512.c new file mode 100644 index 0000000000..f04b440837 --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z96_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z96_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<4;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<55;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<55;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<55;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<55;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<55;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<25;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<16;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<13;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z9_13_AVX512.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z9_13_AVX512.c new file mode 100644 index 0000000000..548ab5f8ab --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/ldpc_gen_files/nrLDPC_cnProc_BG1_Z9_13_AVX512.c @@ -0,0 +1,2340 @@ +#include +#include +__m512i _mm512_sign_epi16(__m512i a, __m512i b){ +b = _mm512_min_epi16(b, _mm512_set1_epi16(1)); +b = _mm512_max_epi16(b, _mm512_set1_epi16(-1)); + a = _mm512_mullo_epi16(a, b); +return a; +} +void nrLDPC_cnProc_BG1_Z9_13_AVX512(int8_t* cnProcBuf,int8_t* cnProcBufRes) { +//Process group with 3 BNs + __m512i zmm0, min, sgn,ones,maxLLR; + ones = _mm512_set1_epi8((char)1); + maxLLR = _mm512_set1_epi8((char)127); + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[0+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[12+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[12+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[13+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[13+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i+=2) { + zmm0 = ((__m512i*)cnProcBuf)[0+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[6+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[24+i] = _mm512_sign_epi16(min, sgn); + zmm0 = ((__m512i*)cnProcBuf)[1+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[7+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[25+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 4 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[36+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[96+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[126+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[156+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[36+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[66+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[96+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[216+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 5 BNs + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[276+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[492+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[708+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[708+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[924+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<7;i++) { + zmm0 = ((__m512i*)cnProcBuf)[276+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[384+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[492+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[600+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1140+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 6 BNs + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1356+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1452+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1548+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1644+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1596+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1740+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<4;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1356+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1404+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1452+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1500+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1548+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1836+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 7 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1932+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[1992+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2052+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2112+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2172+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2112+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2232+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[1932+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1962+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[1992+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2022+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2052+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2082+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2292+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 8 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2352+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2376+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2400+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2424+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2448+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2472+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2408+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2436+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2496+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2352+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2364+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2376+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2388+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2400+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2472+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2424+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2520+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 9 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2544+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2568+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2592+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2616+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2640+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2664+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2688+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2640+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2712+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2544+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2556+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2568+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2580+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2592+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2604+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2616+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2628+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2736+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 10 BNs + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2760+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2772+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2784+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2796+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2808+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2820+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2832+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2844+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2778+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2814+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2856+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<2;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2760+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2766+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2772+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2784+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2790+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2796+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2802+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2808+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2868+i] = _mm512_sign_epi16(min, sgn); + } +//Process group with 19 BNs + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2880+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2928+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[2976+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3024+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3072+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3120+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3168+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3216+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3264+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3312+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3360+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3408+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3456+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3504+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3552+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3600+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3648+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3312+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3696+i] = _mm512_sign_epi16(min, sgn); + } + for (int i=0;i<3;i++) { + zmm0 = ((__m512i*)cnProcBuf)[2880+i]; + sgn = _mm512_sign_epi16(ones, zmm0); + min = _mm512_abs_epi8(zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2904+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2928+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2952+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[2976+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3000+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3024+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3048+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3072+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3096+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3120+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3144+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3168+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3192+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3216+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3240+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3264+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + zmm0 = ((__m512i*)cnProcBuf)[3288+i]; + min = _mm512_min_epu8(min, _mm512_abs_epi8(zmm0)); + sgn = _mm512_sign_epi16(sgn, zmm0); + min = _mm512_min_epu8(min, maxLLR); + ((__m512i*)cnProcBufRes)[3744+i] = _mm512_sign_epi16(min, sgn); + } +} diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_types.h b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_types.h index 196121799c..b802e07104 100644 --- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_types.h +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_types.h @@ -30,7 +30,6 @@ #ifndef __NR_LDPC_TYPES__H__ #define __NR_LDPC_TYPES__H__ - #include "../../TOOLS/time_meas.h" #include "nrLDPCdecoder_defs.h" // ============================================================================== diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPCdecoder_defs.h b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPCdecoder_defs.h index fcb9115ccd..083fe39bff 100644 --- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPCdecoder_defs.h +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPCdecoder_defs.h @@ -191,13 +191,6 @@ static const uint16_t lut_startAddrBnGroupsLlr_BG2_R13[NR_LDPC_NUM_BN_GROUPS_BG2 /** Start address for every BN group within the LLR processing buffer for BG2 rate = 2/3 */ static const uint16_t lut_startAddrBnGroupsLlr_BG2_R23[NR_LDPC_NUM_BN_GROUPS_BG2_R23] = {0, 1152, 2304, 4224, 5376, 6144}; -/** Vector of 64 '1' in int8 for application with AVX512 */ -static const int8_t ones512_epi8[64] __attribute__ ((aligned(64))) = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}; -/** Vector of 64 '0' in int8 for application with AVX512 */ -static const int8_t zeros512_epi8[64] __attribute__ ((aligned(64))) = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; -/** Vector of 64 '127' in int8 for application with AVX512 */ -static const int8_t maxLLR512_epi8[64] __attribute__ ((aligned(64))) = {127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127}; - /** Vector of 32 '1' in int8 for application with AVX2 */ static const int8_t ones256_epi8[32] __attribute__ ((aligned(32))) = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}; /** Vector of 32 '0' in int8 for application with AVX2 */ @@ -205,6 +198,14 @@ static const int8_t zeros256_epi8[32] __attribute__ ((aligned(32))) = {0,0,0,0,0 /** Vector of 32 '127' in int8 for application with AVX2 */ static const int8_t maxLLR256_epi8[32] __attribute__ ((aligned(32))) = {127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127}; +/** Vector of 64 '1' in int8 for application with AVX512 */ +static const int8_t ones512_epi8[64] __attribute__ ((aligned(64))) = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}; +/** Vector of 64 '0' in int8 for application with AVX512 */ +static const int8_t zeros512_epi8[64] __attribute__ ((aligned(64))) = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; +/** Vector of 64 '127' in int8 for application with AVX512 */ +static const int8_t maxLLR512_epi8[64] __attribute__ ((aligned(64))) = {127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127}; + + #endif